From 3c7a0a7a7cda7aead0f473051b4a549dd42ffbac Mon Sep 17 00:00:00 2001
From: BERTHAUT Florent <florent.berthaut@univ-lille1.fr>
Date: Sat, 14 Dec 2019 16:30:27 +0100
Subject: [PATCH] Added first files
---
.gitmodules | 6 +
SConstruct | 114 +
bin/gdpd.gdns | 9 +
bin/libgdpd.gdnlib | 18 +
src/gdlibrary.cpp | 16 +
src/gdpd.cpp | 170 +
src/gdpd.hpp | 59 +
src/godot-cpp | 1 +
src/libpd | 1 +
src/rtaudio/RtAudio.cpp | 10636 ++++++++++++++++++++++++++++++++++++++
src/rtaudio/RtAudio.h | 1203 +++++
src/rtaudio/RtAudio.os | Bin 0 -> 1493776 bytes
12 files changed, 12233 insertions(+)
create mode 100644 .gitmodules
create mode 100644 SConstruct
create mode 100644 bin/gdpd.gdns
create mode 100644 bin/libgdpd.gdnlib
create mode 100644 src/gdlibrary.cpp
create mode 100644 src/gdpd.cpp
create mode 100644 src/gdpd.hpp
create mode 160000 src/godot-cpp
create mode 160000 src/libpd
create mode 100644 src/rtaudio/RtAudio.cpp
create mode 100644 src/rtaudio/RtAudio.h
create mode 100644 src/rtaudio/RtAudio.os
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..2e03585
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,6 @@
+[submodule "src/libpd"]
+ path = src/libpd
+ url = https://github.com/libpd/libpd.git
+[submodule "src/godot-cpp"]
+ path = src/godot-cpp
+ url = https://github.com/GodotNativeTools/godot-cpp
diff --git a/SConstruct b/SConstruct
new file mode 100644
index 0000000..cdc0b7e
--- /dev/null
+++ b/SConstruct
@@ -0,0 +1,114 @@
+#!python
+import os, subprocess
+
+opts = Variables([], ARGUMENTS)
+
+# Gets the standard flags CC, CCX, etc.
+env = DefaultEnvironment()
+
+# Define our options
+opts.Add(EnumVariable('target', "Compilation target", 'debug', ['d', 'debug', 'r', 'release']))
+opts.Add(EnumVariable('platform', "Compilation platform", '', ['', 'windows', 'x11', 'linux', 'osx']))
+opts.Add(EnumVariable('p', "Compilation target, alias for 'platform'", '', ['', 'windows', 'x11', 'linux', 'osx']))
+opts.Add(BoolVariable('use_llvm', "Use the LLVM / Clang compiler", 'no'))
+opts.Add(PathVariable('target_path', 'The path where the lib is installed.', 'bin/'))
+opts.Add(PathVariable('target_name', 'The library name.', 'libgdpd', PathVariable.PathAccept))
+
+# Local dependency paths, adapt them to your setup
+godot_headers_path = "src/godot-cpp/godot_headers/"
+cpp_bindings_path = "src/godot-cpp/"
+cpp_library = "libgodot-cpp"
+
+# only support 64 at this time..
+bits = 64
+
+# Updates the environment with the option variables.
+opts.Update(env)
+
+# Process some arguments
+if env['use_llvm']:
+ env['CC'] = 'clang'
+ env['CXX'] = 'clang++'
+
+if env['p'] != '':
+ env['platform'] = env['p']
+
+if env['platform'] == '':
+ print("No valid target platform selected.")
+ quit();
+
+# For the reference:
+# - CCFLAGS are compilation flags shared between C and C++
+# - CFLAGS are for C-specific compilation flags
+# - CXXFLAGS are for C++-specific compilation flags
+# - CPPFLAGS are for pre-processor flags
+# - CPPDEFINES are for pre-processor defines
+# - LINKFLAGS are for linking flags
+
+# Check our platform specifics
+if env['platform'] == "osx":
+ env['target_path'] += 'osx/'
+ cpp_library += '.osx'
+ if env['target'] in ('debug', 'd'):
+ env.Append(CCFLAGS=['-g', '-O2', '-arch', 'x86_64'])
+ env.Append(LINKFLAGS=['-arch', 'x86_64'])
+ else:
+ env.Append(CCFLAGS=['-g', '-O3', '-arch', 'x86_64'])
+ env.Append(LINKFLAGS=['-arch', 'x86_64'])
+
+elif env['platform'] in ('x11', 'linux'):
+ env['target_path'] += 'x11/'
+ cpp_library += '.linux'
+ env.Append(CPPDEFINES=['__UNIX_JACK__'])
+ env.Append(LINKFLAGS=['-ljack','-pthread'])
+ if env['target'] in ('debug', 'd'):
+ env.Append(CCFLAGS=['-fPIC', '-g3', '-Og'])
+ env.Append(CFLAGS=['-std=c11'])
+ env.Append(CXXFLAGS=['-std=c++17'])
+ else:
+ env.Append(CCFLAGS=['-fPIC', '-g', '-O3'])
+ env.Append(CFLAGS=['-std=c11'])
+ env.Append(CXXFLAGS=['-std=c++17'])
+
+elif env['platform'] == "windows":
+ env['target_path'] += 'win64/'
+ cpp_library += '.windows'
+ # This makes sure to keep the session environment variables on windows,
+ # that way you can run scons in a vs 2017 prompt and it will find all the required tools
+ env.Append(ENV=os.environ)
+
+ env.Append(CPPDEFINES=['WIN32', '_WIN32', '_WINDOWS', '_CRT_SECURE_NO_WARNINGS'])
+ env.Append(CCFLAGS=['-W3', '-GR'])
+ if env['target'] in ('debug', 'd'):
+ env.Append(CPPDEFINES=['_DEBUG'])
+ env.Append(CCFLAGS=['-EHsc', '-MDd', '-ZI'])
+ env.Append(LINKFLAGS=['-DEBUG'])
+ else:
+ env.Append(CPPDEFINES=['NDEBUG'])
+ env.Append(CCFLAGS=['-O2', '-EHsc', '-MD'])
+
+if env['target'] in ('debug', 'd'):
+ cpp_library += '.debug'
+else:
+ cpp_library += '.release'
+
+cpp_library += '.' + str(bits)
+
+# make sure our binding library is properly includes
+env.Append(CPPPATH=['.', godot_headers_path, cpp_bindings_path + 'include/', cpp_bindings_path + 'include/core/', cpp_bindings_path + 'include/gen/', 'src/libpd/cpp','src/libpd/pure-data/src', 'src/libpd/libpd_wrapper', 'src/libpd/libpd_wrapper/util', 'src/rtaudio'])
+env.Append(LIBPATH=[cpp_bindings_path + 'bin/'])
+env.Append(LIBS=[cpp_library])
+env.Append(CFLAGS=['-DUSEAPI_DUMMY', '-DPD', '-DHAVE_UNISTD_H', '-D_GNU_SOURCE'])
+
+# tweak this if you want to use different folders, or more folders, to store your source code in.
+env.Append(CPPPATH=['src/'])
+
+#sources = Glob('src/*.cpp')
+sources = Glob('src/*.cpp') + Glob('src/rtaudio/*.cpp') + Glob('src/libpd/libpd_wrapper/*.c') + Glob('src/libpd/libpd_wrapper/util/*.c') + Glob('src/libpd/pure-data/extra/**/*.c') + Glob('src/libpd/pure-data/src/[xmgz]_*.c') + Glob('src/libpd/pure-data/src/d_[acgmorsu]*.c') + Glob('src/libpd/pure-data/src/d_dac.c') + Glob('src/libpd/pure-data/src/d_delay.c') + Glob('src/libpd/pure-data/src/d_fft.c') + Glob('src/libpd/pure-data/src/d_fft_fftsg.c') + Glob('src/libpd/pure-data/src/d_filter.c') + Glob('src/libpd/pure-data/src/s_audio.c') + Glob('src/libpd/pure-data/src/s_audio_dummy.c') + Glob('src/libpd/pure-data/src/s_print.c') + Glob('src/libpd/pure-data/src/s_path.c') + Glob('src/libpd/pure-data/src/s_main.c') + Glob('src/libpd/pure-data/src/s_inter.c') + Glob('src/libpd/pure-data/src/s_utf8.c') + Glob('src/libpd/pure-data/src/s_loader.c')
+
+library = env.SharedLibrary(target=env['target_path'] + env['target_name'] , source=sources)
+
+Default(library)
+
+# Generates help for the -h scons option.
+Help(opts.GenerateHelpText(env))
diff --git a/bin/gdpd.gdns b/bin/gdpd.gdns
new file mode 100644
index 0000000..4a291d7
--- /dev/null
+++ b/bin/gdpd.gdns
@@ -0,0 +1,9 @@
+[gd_resource type="NativeScript" load_steps=2 format=2]
+
+[ext_resource path="res://addons/gdpd/bin/libgdpd.gdnlib" type="GDNativeLibrary" id=1]
+
+[resource]
+resource_name = "gdpd"
+class_name = "Gdpd"
+library = ExtResource( 1 )
+_sections_unfolded = [ "Resource" ]
diff --git a/bin/libgdpd.gdnlib b/bin/libgdpd.gdnlib
new file mode 100644
index 0000000..99933eb
--- /dev/null
+++ b/bin/libgdpd.gdnlib
@@ -0,0 +1,18 @@
+[general]
+
+singleton=false
+load_once=true
+symbol_prefix="godot_"
+reloadable=true
+
+[entry]
+
+X11.64="res://addons/gdpd/bin/x11/libgdpd.so"
+Windows.64="res://addons/gdpd/bin/win/libgdpd.dll"
+OSX.64="res://addons/gdpd/bin/osx/libgdpd.dylib"
+
+[dependencies]
+
+X11.64=[]
+Windows.64=[ ]
+OSX.64=[ ]
diff --git a/src/gdlibrary.cpp b/src/gdlibrary.cpp
new file mode 100644
index 0000000..0381d24
--- /dev/null
+++ b/src/gdlibrary.cpp
@@ -0,0 +1,16 @@
+#include "gdpd.hpp"
+
+extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) {
+ godot::Godot::gdnative_init(o);
+}
+
+extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o) {
+ godot::Godot::gdnative_terminate(o);
+}
+
+extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) {
+ godot::Godot::nativescript_init(handle);
+
+ godot::register_class<godot::Gdpd>();
+}
+
diff --git a/src/gdpd.cpp b/src/gdpd.cpp
new file mode 100644
index 0000000..ddabb74
--- /dev/null
+++ b/src/gdpd.cpp
@@ -0,0 +1,170 @@
+#include "gdpd.hpp"
+
+using namespace godot;
+
+void Gdpd::_register_methods() {
+ register_method("init", &Gdpd::init);
+ register_method("openfile", &Gdpd::openfile);
+ register_method("closefile", &Gdpd::closefile);
+ register_method("has_message", &Gdpd::has_message);
+ register_method("get_next", &Gdpd::get_next);
+ register_method("start_message", &Gdpd::start_message);
+ register_method("add_symbol", &Gdpd::add_symbol);
+ register_method("add_float", &Gdpd::add_float);
+ register_method("finish_list", &Gdpd::finish_list);
+}
+
+int Gdpd::audioCallback(void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames, double streamTime, RtAudioStreamStatus status, void *userData){
+ // pass audio samples to/from libpd
+ int ticks = nBufferFrames / 64;
+ libpd_process_float(ticks, (float*)inputBuffer, (float*)outputBuffer);
+ return 0;
+}
+
+
+Gdpd::Gdpd() {
+}
+
+void Gdpd::_init() {
+
+}
+
+Gdpd::~Gdpd() {
+ // add your cleanup here
+}
+
+int Gdpd::init(int nbInputs, int nbOutputs, int sampleRate) {
+
+
+ if(!m_pd.init(nbInputs, nbOutputs, sampleRate, true)) {
+ Godot::print("GDPD : Error starting libpd");
+ return 1;
+ }
+
+ /*
+ int bufsize = 128;
+ m_inBuf = new float[bufsize * nbInputs];
+ m_outBuf = new float[bufsize * nbOutputs];
+ */
+
+ //create message array
+ m_messages = new Array();
+
+ //create message hook
+ m_pd.subscribe("to_gdpd");
+ m_pd.setReceiver(this);
+
+ //start dsp
+ m_pd.computeAudio(true);
+
+ //intialize rtaudio
+ if(m_audio.getDeviceCount()==0){
+ Godot::print("There are no available sound devices.");
+ }
+
+ RtAudio::StreamParameters outParams, inParams;
+ unsigned int sr = m_audio.getDeviceInfo(outParams.deviceId).preferredSampleRate;
+ outParams.deviceId = m_audio.getDefaultOutputDevice();
+ inParams.deviceId = m_audio.getDefaultOutputDevice();
+ outParams.nChannels = nbInputs;
+ inParams.nChannels = nbOutputs;
+ m_bufferFrames = 128;
+
+ RtAudio::StreamOptions options;
+ options.streamName = "gdpd";
+ options.flags = RTAUDIO_SCHEDULE_REALTIME;
+ if(m_audio.getCurrentApi() != RtAudio::MACOSX_CORE) {
+ options.flags |= RTAUDIO_MINIMIZE_LATENCY; // CoreAudio doesn't seem to like this
+ }
+ try {
+ m_audio.openStream(&outParams, &inParams, RTAUDIO_FLOAT32,
+ sr, &m_bufferFrames, &audioCallback,
+ &m_pd, &options);
+ m_audio.startStream();
+ }
+ catch(RtAudioError& e) {
+ Godot::print(e.getMessage().c_str());
+ }
+
+
+ Godot::print("GDPD : Initialized");
+
+ return 0;
+}
+
+void Gdpd::openfile(godot::String baseStr, godot::String dirStr) {
+ std::wstring baseWs = baseStr.unicode_str();
+ std::string baseS(baseWs.begin(), baseWs.end());
+ std::wstring dirWs = dirStr.unicode_str();
+ std::string dirS(dirWs.begin(), dirWs.end());
+
+ libpd_openfile(baseS.c_str(), dirS.c_str());
+
+ Godot::print("GDPD : Opened patch");
+}
+
+void Gdpd::closefile() {
+ m_pd.closePatch(m_patch);
+}
+
+bool Gdpd::has_message() {
+ //receive new messages
+ m_pd.receiveMessages();
+
+ //return if more than one message
+ int size = m_messages->size();
+ return size>0;
+}
+
+Array Gdpd::get_next() {
+ Array msg = m_messages->pop_front();
+ return msg;
+}
+
+int Gdpd::blocksize() {
+ int blocksize = libpd_blocksize();
+ return blocksize;
+}
+
+int Gdpd::start_message(int nbValues) {
+ int res = libpd_start_message(nbValues);
+ return res;
+}
+
+void Gdpd::add_symbol(String symbStr) {
+ std::wstring symbWs = symbStr.unicode_str();
+ std::string symbS(symbWs.begin(), symbWs.end());
+ libpd_add_symbol(symbS.c_str());
+}
+
+void Gdpd::add_float(float val) {
+ libpd_add_float(val);
+}
+
+int Gdpd::finish_list(String destStr) {
+ std::wstring destWs = destStr.unicode_str();
+ std::string destS(destWs.begin(), destWs.end());
+ int res = libpd_finish_list(destS.c_str());
+ return res;
+}
+
+
+void Gdpd::print(const std::string& message) {
+ Godot::print(message.c_str());
+}
+
+void Gdpd::receiveList(const std::string& dest, const pd::List& list) {
+ Array gdlist;
+
+ for(int i = 0; i < list.len(); ++i) {
+ if(list.isFloat(i)) {
+ gdlist.push_back(list.getFloat(i));
+ }
+ else if(list.isSymbol(i)) {
+ String symbStr(list.getSymbol(i).c_str());
+ gdlist.push_back(symbStr);
+ }
+ }
+
+ m_messages->push_back(gdlist);
+}
diff --git a/src/gdpd.hpp b/src/gdpd.hpp
new file mode 100644
index 0000000..51c6edf
--- /dev/null
+++ b/src/gdpd.hpp
@@ -0,0 +1,59 @@
+#ifndef GDPD_H
+#define GDPD_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <Godot.hpp>
+#include <AudioStreamPlayer.hpp>
+
+#include "PdBase.hpp"
+#include "PdReceiver.hpp"
+#include "RtAudio.h"
+
+namespace godot {
+
+class Gdpd : public godot::AudioStreamPlayer, public pd::PdReceiver {
+ GODOT_CLASS(Gdpd, AudioStreamPlayer)
+
+private:
+ float *m_inBuf;
+ float *m_outBuf;
+ Array* m_messages;
+ pd::PdBase m_pd;
+ pd::Patch m_patch;
+ RtAudio m_audio;
+ unsigned int m_bufferFrames;
+
+public:
+ static void _register_methods();
+
+ Gdpd();
+ ~Gdpd();
+
+ void _init();
+
+ //libpd functions
+ int init(int nbInputs, int nbOutputs, int sampleRate);
+ void openfile(String basename, String dirname);
+ void closefile();
+ bool has_message();
+ Array get_next();
+ int blocksize();
+ int start_message(int nbValues);
+ void add_symbol(String symbStr);
+ void add_float(float val);
+ int finish_list(String destStr);
+
+ //libpd hooks
+ void print(const std::string& message);
+ void receiveList(const std::string& dest, const pd::List& list);
+
+ static int audioCallback(void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames, double streamTime, RtAudioStreamStatus status, void *userData);
+
+};
+
+}
+
+#endif
diff --git a/src/godot-cpp b/src/godot-cpp
new file mode 160000
index 0000000..3ee07f6
--- /dev/null
+++ b/src/godot-cpp
@@ -0,0 +1 @@
+Subproject commit 3ee07f652bbbe91630a8346e3fe39a05f0f1d76a
diff --git a/src/libpd b/src/libpd
new file mode 160000
index 0000000..e07d211
--- /dev/null
+++ b/src/libpd
@@ -0,0 +1 @@
+Subproject commit e07d211d7b7e5f8dd6d2e3ddce557ae453161a14
diff --git a/src/rtaudio/RtAudio.cpp b/src/rtaudio/RtAudio.cpp
new file mode 100644
index 0000000..0837d98
--- /dev/null
+++ b/src/rtaudio/RtAudio.cpp
@@ -0,0 +1,10636 @@
+/************************************************************************/
+/*! \class RtAudio
+ \brief Realtime audio i/o C++ classes.
+
+ RtAudio provides a common API (Application Programming Interface)
+ for realtime audio input/output across Linux (native ALSA, Jack,
+ and OSS), Macintosh OS X (CoreAudio and Jack), and Windows
+ (DirectSound, ASIO and WASAPI) operating systems.
+
+ RtAudio GitHub site: https://github.com/thestk/rtaudio
+ RtAudio WWW site: http://www.music.mcgill.ca/~gary/rtaudio/
+
+ RtAudio: realtime audio i/o C++ classes
+ Copyright (c) 2001-2019 Gary P. Scavone
+
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation files
+ (the "Software"), to deal in the Software without restriction,
+ including without limitation the rights to use, copy, modify, merge,
+ publish, distribute, sublicense, and/or sell copies of the Software,
+ and to permit persons to whom the Software is furnished to do so,
+ subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ Any person wishing to distribute modifications to the Software is
+ asked to send the modifications to the original developer so that
+ they can be incorporated into the canonical version. This is,
+ however, not a binding provision of this license.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+/************************************************************************/
+
+// RtAudio: Version 5.1.0
+
+#include "RtAudio.h"
+#include <iostream>
+#include <cstdlib>
+#include <cstring>
+#include <climits>
+#include <cmath>
+#include <algorithm>
+
+// Static variable definitions.
+const unsigned int RtApi::MAX_SAMPLE_RATES = 14;
+const unsigned int RtApi::SAMPLE_RATES[] = {
+ 4000, 5512, 8000, 9600, 11025, 16000, 22050,
+ 32000, 44100, 48000, 88200, 96000, 176400, 192000
+};
+
+#if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__) || defined(__WINDOWS_WASAPI__)
+ #define MUTEX_INITIALIZE(A) InitializeCriticalSection(A)
+ #define MUTEX_DESTROY(A) DeleteCriticalSection(A)
+ #define MUTEX_LOCK(A) EnterCriticalSection(A)
+ #define MUTEX_UNLOCK(A) LeaveCriticalSection(A)
+
+ #include "tchar.h"
+
+ static std::string convertCharPointerToStdString(const char *text)
+ {
+ return std::string(text);
+ }
+
+ static std::string convertCharPointerToStdString(const wchar_t *text)
+ {
+ int length = WideCharToMultiByte(CP_UTF8, 0, text, -1, NULL, 0, NULL, NULL);
+ std::string s( length-1, '\0' );
+ WideCharToMultiByte(CP_UTF8, 0, text, -1, &s[0], length, NULL, NULL);
+ return s;
+ }
+
+#elif defined(__LINUX_ALSA__) || defined(__LINUX_PULSE__) || defined(__UNIX_JACK__) || defined(__LINUX_OSS__) || defined(__MACOSX_CORE__)
+ // pthread API
+ #define MUTEX_INITIALIZE(A) pthread_mutex_init(A, NULL)
+ #define MUTEX_DESTROY(A) pthread_mutex_destroy(A)
+ #define MUTEX_LOCK(A) pthread_mutex_lock(A)
+ #define MUTEX_UNLOCK(A) pthread_mutex_unlock(A)
+#else
+ #define MUTEX_INITIALIZE(A) abs(*A) // dummy definitions
+ #define MUTEX_DESTROY(A) abs(*A) // dummy definitions
+#endif
+
+// *************************************************** //
+//
+// RtAudio definitions.
+//
+// *************************************************** //
+
+std::string RtAudio :: getVersion( void )
+{
+ return RTAUDIO_VERSION;
+}
+
+// Define API names and display names.
+// Must be in same order as API enum.
+extern "C" {
+const char* rtaudio_api_names[][2] = {
+ { "unspecified" , "Unknown" },
+ { "alsa" , "ALSA" },
+ { "pulse" , "Pulse" },
+ { "oss" , "OpenSoundSystem" },
+ { "jack" , "Jack" },
+ { "core" , "CoreAudio" },
+ { "wasapi" , "WASAPI" },
+ { "asio" , "ASIO" },
+ { "ds" , "DirectSound" },
+ { "dummy" , "Dummy" },
+};
+const unsigned int rtaudio_num_api_names =
+ sizeof(rtaudio_api_names)/sizeof(rtaudio_api_names[0]);
+
+// The order here will control the order of RtAudio's API search in
+// the constructor.
+extern "C" const RtAudio::Api rtaudio_compiled_apis[] = {
+#if defined(__UNIX_JACK__)
+ RtAudio::UNIX_JACK,
+#endif
+#if defined(__LINUX_PULSE__)
+ RtAudio::LINUX_PULSE,
+#endif
+#if defined(__LINUX_ALSA__)
+ RtAudio::LINUX_ALSA,
+#endif
+#if defined(__LINUX_OSS__)
+ RtAudio::LINUX_OSS,
+#endif
+#if defined(__WINDOWS_ASIO__)
+ RtAudio::WINDOWS_ASIO,
+#endif
+#if defined(__WINDOWS_WASAPI__)
+ RtAudio::WINDOWS_WASAPI,
+#endif
+#if defined(__WINDOWS_DS__)
+ RtAudio::WINDOWS_DS,
+#endif
+#if defined(__MACOSX_CORE__)
+ RtAudio::MACOSX_CORE,
+#endif
+#if defined(__RTAUDIO_DUMMY__)
+ RtAudio::RTAUDIO_DUMMY,
+#endif
+ RtAudio::UNSPECIFIED,
+};
+extern "C" const unsigned int rtaudio_num_compiled_apis =
+ sizeof(rtaudio_compiled_apis)/sizeof(rtaudio_compiled_apis[0])-1;
+}
+
+// This is a compile-time check that rtaudio_num_api_names == RtAudio::NUM_APIS.
+// If the build breaks here, check that they match.
+template<bool b> class StaticAssert { private: StaticAssert() {} };
+template<> class StaticAssert<true>{ public: StaticAssert() {} };
+class StaticAssertions { StaticAssertions() {
+ StaticAssert<rtaudio_num_api_names == RtAudio::NUM_APIS>();
+}};
+
+void RtAudio :: getCompiledApi( std::vector<RtAudio::Api> &apis )
+{
+ apis = std::vector<RtAudio::Api>(rtaudio_compiled_apis,
+ rtaudio_compiled_apis + rtaudio_num_compiled_apis);
+}
+
+std::string RtAudio :: getApiName( RtAudio::Api api )
+{
+ if (api < 0 || api >= RtAudio::NUM_APIS)
+ return "";
+ return rtaudio_api_names[api][0];
+}
+
+std::string RtAudio :: getApiDisplayName( RtAudio::Api api )
+{
+ if (api < 0 || api >= RtAudio::NUM_APIS)
+ return "Unknown";
+ return rtaudio_api_names[api][1];
+}
+
+RtAudio::Api RtAudio :: getCompiledApiByName( const std::string &name )
+{
+ unsigned int i=0;
+ for (i = 0; i < rtaudio_num_compiled_apis; ++i)
+ if (name == rtaudio_api_names[rtaudio_compiled_apis[i]][0])
+ return rtaudio_compiled_apis[i];
+ return RtAudio::UNSPECIFIED;
+}
+
+void RtAudio :: openRtApi( RtAudio::Api api )
+{
+ if ( rtapi_ )
+ delete rtapi_;
+ rtapi_ = 0;
+
+#if defined(__UNIX_JACK__)
+ if ( api == UNIX_JACK )
+ rtapi_ = new RtApiJack();
+#endif
+#if defined(__LINUX_ALSA__)
+ if ( api == LINUX_ALSA )
+ rtapi_ = new RtApiAlsa();
+#endif
+#if defined(__LINUX_PULSE__)
+ if ( api == LINUX_PULSE )
+ rtapi_ = new RtApiPulse();
+#endif
+#if defined(__LINUX_OSS__)
+ if ( api == LINUX_OSS )
+ rtapi_ = new RtApiOss();
+#endif
+#if defined(__WINDOWS_ASIO__)
+ if ( api == WINDOWS_ASIO )
+ rtapi_ = new RtApiAsio();
+#endif
+#if defined(__WINDOWS_WASAPI__)
+ if ( api == WINDOWS_WASAPI )
+ rtapi_ = new RtApiWasapi();
+#endif
+#if defined(__WINDOWS_DS__)
+ if ( api == WINDOWS_DS )
+ rtapi_ = new RtApiDs();
+#endif
+#if defined(__MACOSX_CORE__)
+ if ( api == MACOSX_CORE )
+ rtapi_ = new RtApiCore();
+#endif
+#if defined(__RTAUDIO_DUMMY__)
+ if ( api == RTAUDIO_DUMMY )
+ rtapi_ = new RtApiDummy();
+#endif
+}
+
+RtAudio :: RtAudio( RtAudio::Api api )
+{
+ rtapi_ = 0;
+
+ if ( api != UNSPECIFIED ) {
+ // Attempt to open the specified API.
+ openRtApi( api );
+ if ( rtapi_ ) return;
+
+ // No compiled support for specified API value. Issue a debug
+ // warning and continue as if no API was specified.
+ std::cerr << "\nRtAudio: no compiled support for specified API argument!\n" << std::endl;
+ }
+
+ // Iterate through the compiled APIs and return as soon as we find
+ // one with at least one device or we reach the end of the list.
+ std::vector< RtAudio::Api > apis;
+ getCompiledApi( apis );
+ for ( unsigned int i=0; i<apis.size(); i++ ) {
+ openRtApi( apis[i] );
+ if ( rtapi_ && rtapi_->getDeviceCount() ) break;
+ }
+
+ if ( rtapi_ ) return;
+
+ // It should not be possible to get here because the preprocessor
+ // definition __RTAUDIO_DUMMY__ is automatically defined if no
+ // API-specific definitions are passed to the compiler. But just in
+ // case something weird happens, we'll thow an error.
+ std::string errorText = "\nRtAudio: no compiled API support found ... critical error!!\n\n";
+ throw( RtAudioError( errorText, RtAudioError::UNSPECIFIED ) );
+}
+
+RtAudio :: ~RtAudio()
+{
+ if ( rtapi_ )
+ delete rtapi_;
+}
+
+void RtAudio :: openStream( RtAudio::StreamParameters *outputParameters,
+ RtAudio::StreamParameters *inputParameters,
+ RtAudioFormat format, unsigned int sampleRate,
+ unsigned int *bufferFrames,
+ RtAudioCallback callback, void *userData,
+ RtAudio::StreamOptions *options,
+ RtAudioErrorCallback errorCallback )
+{
+ return rtapi_->openStream( outputParameters, inputParameters, format,
+ sampleRate, bufferFrames, callback,
+ userData, options, errorCallback );
+}
+
+// *************************************************** //
+//
+// Public RtApi definitions (see end of file for
+// private or protected utility functions).
+//
+// *************************************************** //
+
+RtApi :: RtApi()
+{
+ stream_.state = STREAM_CLOSED;
+ stream_.mode = UNINITIALIZED;
+ stream_.apiHandle = 0;
+ stream_.userBuffer[0] = 0;
+ stream_.userBuffer[1] = 0;
+ MUTEX_INITIALIZE( &stream_.mutex );
+ showWarnings_ = true;
+ firstErrorOccurred_ = false;
+}
+
+RtApi :: ~RtApi()
+{
+ MUTEX_DESTROY( &stream_.mutex );
+}
+
+void RtApi :: openStream( RtAudio::StreamParameters *oParams,
+ RtAudio::StreamParameters *iParams,
+ RtAudioFormat format, unsigned int sampleRate,
+ unsigned int *bufferFrames,
+ RtAudioCallback callback, void *userData,
+ RtAudio::StreamOptions *options,
+ RtAudioErrorCallback errorCallback )
+{
+ if ( stream_.state != STREAM_CLOSED ) {
+ errorText_ = "RtApi::openStream: a stream is already open!";
+ error( RtAudioError::INVALID_USE );
+ return;
+ }
+
+ // Clear stream information potentially left from a previously open stream.
+ clearStreamInfo();
+
+ if ( oParams && oParams->nChannels < 1 ) {
+ errorText_ = "RtApi::openStream: a non-NULL output StreamParameters structure cannot have an nChannels value less than one.";
+ error( RtAudioError::INVALID_USE );
+ return;
+ }
+
+ if ( iParams && iParams->nChannels < 1 ) {
+ errorText_ = "RtApi::openStream: a non-NULL input StreamParameters structure cannot have an nChannels value less than one.";
+ error( RtAudioError::INVALID_USE );
+ return;
+ }
+
+ if ( oParams == NULL && iParams == NULL ) {
+ errorText_ = "RtApi::openStream: input and output StreamParameters structures are both NULL!";
+ error( RtAudioError::INVALID_USE );
+ return;
+ }
+
+ if ( formatBytes(format) == 0 ) {
+ errorText_ = "RtApi::openStream: 'format' parameter value is undefined.";
+ error( RtAudioError::INVALID_USE );
+ return;
+ }
+
+ unsigned int nDevices = getDeviceCount();
+ unsigned int oChannels = 0;
+ if ( oParams ) {
+ oChannels = oParams->nChannels;
+ if ( oParams->deviceId >= nDevices ) {
+ errorText_ = "RtApi::openStream: output device parameter value is invalid.";
+ error( RtAudioError::INVALID_USE );
+ return;
+ }
+ }
+
+ unsigned int iChannels = 0;
+ if ( iParams ) {
+ iChannels = iParams->nChannels;
+ if ( iParams->deviceId >= nDevices ) {
+ errorText_ = "RtApi::openStream: input device parameter value is invalid.";
+ error( RtAudioError::INVALID_USE );
+ return;
+ }
+ }
+
+ bool result;
+
+ if ( oChannels > 0 ) {
+
+ result = probeDeviceOpen( oParams->deviceId, OUTPUT, oChannels, oParams->firstChannel,
+ sampleRate, format, bufferFrames, options );
+ if ( result == false ) {
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+ }
+
+ if ( iChannels > 0 ) {
+
+ result = probeDeviceOpen( iParams->deviceId, INPUT, iChannels, iParams->firstChannel,
+ sampleRate, format, bufferFrames, options );
+ if ( result == false ) {
+ if ( oChannels > 0 ) closeStream();
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+ }
+
+ stream_.callbackInfo.callback = (void *) callback;
+ stream_.callbackInfo.userData = userData;
+ stream_.callbackInfo.errorCallback = (void *) errorCallback;
+
+ if ( options ) options->numberOfBuffers = stream_.nBuffers;
+ stream_.state = STREAM_STOPPED;
+}
+
+unsigned int RtApi :: getDefaultInputDevice( void )
+{
+ // Should be implemented in subclasses if possible.
+ return 0;
+}
+
+unsigned int RtApi :: getDefaultOutputDevice( void )
+{
+ // Should be implemented in subclasses if possible.
+ return 0;
+}
+
+void RtApi :: closeStream( void )
+{
+ // MUST be implemented in subclasses!
+ return;
+}
+
+bool RtApi :: probeDeviceOpen( unsigned int /*device*/, StreamMode /*mode*/, unsigned int /*channels*/,
+ unsigned int /*firstChannel*/, unsigned int /*sampleRate*/,
+ RtAudioFormat /*format*/, unsigned int * /*bufferSize*/,
+ RtAudio::StreamOptions * /*options*/ )
+{
+ // MUST be implemented in subclasses!
+ return FAILURE;
+}
+
+void RtApi :: tickStreamTime( void )
+{
+ // Subclasses that do not provide their own implementation of
+ // getStreamTime should call this function once per buffer I/O to
+ // provide basic stream time support.
+
+ stream_.streamTime += ( stream_.bufferSize * 1.0 / stream_.sampleRate );
+
+#if defined( HAVE_GETTIMEOFDAY )
+ gettimeofday( &stream_.lastTickTimestamp, NULL );
+#endif
+}
+
+long RtApi :: getStreamLatency( void )
+{
+ verifyStream();
+
+ long totalLatency = 0;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX )
+ totalLatency = stream_.latency[0];
+ if ( stream_.mode == INPUT || stream_.mode == DUPLEX )
+ totalLatency += stream_.latency[1];
+
+ return totalLatency;
+}
+
+double RtApi :: getStreamTime( void )
+{
+ verifyStream();
+
+#if defined( HAVE_GETTIMEOFDAY )
+ // Return a very accurate estimate of the stream time by
+ // adding in the elapsed time since the last tick.
+ struct timeval then;
+ struct timeval now;
+
+ if ( stream_.state != STREAM_RUNNING || stream_.streamTime == 0.0 )
+ return stream_.streamTime;
+
+ gettimeofday( &now, NULL );
+ then = stream_.lastTickTimestamp;
+ return stream_.streamTime +
+ ((now.tv_sec + 0.000001 * now.tv_usec) -
+ (then.tv_sec + 0.000001 * then.tv_usec));
+#else
+ return stream_.streamTime;
+#endif
+}
+
+void RtApi :: setStreamTime( double time )
+{
+ verifyStream();
+
+ if ( time >= 0.0 )
+ stream_.streamTime = time;
+#if defined( HAVE_GETTIMEOFDAY )
+ gettimeofday( &stream_.lastTickTimestamp, NULL );
+#endif
+}
+
+unsigned int RtApi :: getStreamSampleRate( void )
+{
+ verifyStream();
+
+ return stream_.sampleRate;
+}
+
+
+// *************************************************** //
+//
+// OS/API-specific methods.
+//
+// *************************************************** //
+
+#if defined(__MACOSX_CORE__)
+
+// The OS X CoreAudio API is designed to use a separate callback
+// procedure for each of its audio devices. A single RtAudio duplex
+// stream using two different devices is supported here, though it
+// cannot be guaranteed to always behave correctly because we cannot
+// synchronize these two callbacks.
+//
+// A property listener is installed for over/underrun information.
+// However, no functionality is currently provided to allow property
+// listeners to trigger user handlers because it is unclear what could
+// be done if a critical stream parameter (buffer size, sample rate,
+// device disconnect) notification arrived. The listeners entail
+// quite a bit of extra code and most likely, a user program wouldn't
+// be prepared for the result anyway. However, we do provide a flag
+// to the client callback function to inform of an over/underrun.
+
+// A structure to hold various information related to the CoreAudio API
+// implementation.
+struct CoreHandle {
+ AudioDeviceID id[2]; // device ids
+#if defined( MAC_OS_X_VERSION_10_5 ) && ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 )
+ AudioDeviceIOProcID procId[2];
+#endif
+ UInt32 iStream[2]; // device stream index (or first if using multiple)
+ UInt32 nStreams[2]; // number of streams to use
+ bool xrun[2];
+ char *deviceBuffer;
+ pthread_cond_t condition;
+ int drainCounter; // Tracks callback counts when draining
+ bool internalDrain; // Indicates if stop is initiated from callback or not.
+
+ CoreHandle()
+ :deviceBuffer(0), drainCounter(0), internalDrain(false) { nStreams[0] = 1; nStreams[1] = 1; id[0] = 0; id[1] = 0; xrun[0] = false; xrun[1] = false; }
+};
+
+RtApiCore:: RtApiCore()
+{
+#if defined( AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER )
+ // This is a largely undocumented but absolutely necessary
+ // requirement starting with OS-X 10.6. If not called, queries and
+ // updates to various audio device properties are not handled
+ // correctly.
+ CFRunLoopRef theRunLoop = NULL;
+ AudioObjectPropertyAddress property = { kAudioHardwarePropertyRunLoop,
+ kAudioObjectPropertyScopeGlobal,
+ kAudioObjectPropertyElementMaster };
+ OSStatus result = AudioObjectSetPropertyData( kAudioObjectSystemObject, &property, 0, NULL, sizeof(CFRunLoopRef), &theRunLoop);
+ if ( result != noErr ) {
+ errorText_ = "RtApiCore::RtApiCore: error setting run loop property!";
+ error( RtAudioError::WARNING );
+ }
+#endif
+}
+
+RtApiCore :: ~RtApiCore()
+{
+ // The subclass destructor gets called before the base class
+ // destructor, so close an existing stream before deallocating
+ // apiDeviceId memory.
+ if ( stream_.state != STREAM_CLOSED ) closeStream();
+}
+
+unsigned int RtApiCore :: getDeviceCount( void )
+{
+ // Find out how many audio devices there are, if any.
+ UInt32 dataSize;
+ AudioObjectPropertyAddress propertyAddress = { kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
+ OSStatus result = AudioObjectGetPropertyDataSize( kAudioObjectSystemObject, &propertyAddress, 0, NULL, &dataSize );
+ if ( result != noErr ) {
+ errorText_ = "RtApiCore::getDeviceCount: OS-X error getting device info!";
+ error( RtAudioError::WARNING );
+ return 0;
+ }
+
+ return dataSize / sizeof( AudioDeviceID );
+}
+
+unsigned int RtApiCore :: getDefaultInputDevice( void )
+{
+ unsigned int nDevices = getDeviceCount();
+ if ( nDevices <= 1 ) return 0;
+
+ AudioDeviceID id;
+ UInt32 dataSize = sizeof( AudioDeviceID );
+ AudioObjectPropertyAddress property = { kAudioHardwarePropertyDefaultInputDevice, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
+ OSStatus result = AudioObjectGetPropertyData( kAudioObjectSystemObject, &property, 0, NULL, &dataSize, &id );
+ if ( result != noErr ) {
+ errorText_ = "RtApiCore::getDefaultInputDevice: OS-X system error getting device.";
+ error( RtAudioError::WARNING );
+ return 0;
+ }
+
+ dataSize *= nDevices;
+ AudioDeviceID deviceList[ nDevices ];
+ property.mSelector = kAudioHardwarePropertyDevices;
+ result = AudioObjectGetPropertyData( kAudioObjectSystemObject, &property, 0, NULL, &dataSize, (void *) &deviceList );
+ if ( result != noErr ) {
+ errorText_ = "RtApiCore::getDefaultInputDevice: OS-X system error getting device IDs.";
+ error( RtAudioError::WARNING );
+ return 0;
+ }
+
+ for ( unsigned int i=0; i<nDevices; i++ )
+ if ( id == deviceList[i] ) return i;
+
+ errorText_ = "RtApiCore::getDefaultInputDevice: No default device found!";
+ error( RtAudioError::WARNING );
+ return 0;
+}
+
+unsigned int RtApiCore :: getDefaultOutputDevice( void )
+{
+ unsigned int nDevices = getDeviceCount();
+ if ( nDevices <= 1 ) return 0;
+
+ AudioDeviceID id;
+ UInt32 dataSize = sizeof( AudioDeviceID );
+ AudioObjectPropertyAddress property = { kAudioHardwarePropertyDefaultOutputDevice, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
+ OSStatus result = AudioObjectGetPropertyData( kAudioObjectSystemObject, &property, 0, NULL, &dataSize, &id );
+ if ( result != noErr ) {
+ errorText_ = "RtApiCore::getDefaultOutputDevice: OS-X system error getting device.";
+ error( RtAudioError::WARNING );
+ return 0;
+ }
+
+ dataSize = sizeof( AudioDeviceID ) * nDevices;
+ AudioDeviceID deviceList[ nDevices ];
+ property.mSelector = kAudioHardwarePropertyDevices;
+ result = AudioObjectGetPropertyData( kAudioObjectSystemObject, &property, 0, NULL, &dataSize, (void *) &deviceList );
+ if ( result != noErr ) {
+ errorText_ = "RtApiCore::getDefaultOutputDevice: OS-X system error getting device IDs.";
+ error( RtAudioError::WARNING );
+ return 0;
+ }
+
+ for ( unsigned int i=0; i<nDevices; i++ )
+ if ( id == deviceList[i] ) return i;
+
+ errorText_ = "RtApiCore::getDefaultOutputDevice: No default device found!";
+ error( RtAudioError::WARNING );
+ return 0;
+}
+
+RtAudio::DeviceInfo RtApiCore :: getDeviceInfo( unsigned int device )
+{
+ RtAudio::DeviceInfo info;
+ info.probed = false;
+
+ // Get device ID
+ unsigned int nDevices = getDeviceCount();
+ if ( nDevices == 0 ) {
+ errorText_ = "RtApiCore::getDeviceInfo: no devices found!";
+ error( RtAudioError::INVALID_USE );
+ return info;
+ }
+
+ if ( device >= nDevices ) {
+ errorText_ = "RtApiCore::getDeviceInfo: device ID is invalid!";
+ error( RtAudioError::INVALID_USE );
+ return info;
+ }
+
+ AudioDeviceID deviceList[ nDevices ];
+ UInt32 dataSize = sizeof( AudioDeviceID ) * nDevices;
+ AudioObjectPropertyAddress property = { kAudioHardwarePropertyDevices,
+ kAudioObjectPropertyScopeGlobal,
+ kAudioObjectPropertyElementMaster };
+ OSStatus result = AudioObjectGetPropertyData( kAudioObjectSystemObject, &property,
+ 0, NULL, &dataSize, (void *) &deviceList );
+ if ( result != noErr ) {
+ errorText_ = "RtApiCore::getDeviceInfo: OS-X system error getting device IDs.";
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ AudioDeviceID id = deviceList[ device ];
+
+ // Get the device name.
+ info.name.erase();
+ CFStringRef cfname;
+ dataSize = sizeof( CFStringRef );
+ property.mSelector = kAudioObjectPropertyManufacturer;
+ result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &cfname );
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::probeDeviceInfo: system error (" << getErrorCode( result ) << ") getting device manufacturer.";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ //const char *mname = CFStringGetCStringPtr( cfname, CFStringGetSystemEncoding() );
+ int length = CFStringGetLength(cfname);
+ char *mname = (char *)malloc(length * 3 + 1);
+#if defined( UNICODE ) || defined( _UNICODE )
+ CFStringGetCString(cfname, mname, length * 3 + 1, kCFStringEncodingUTF8);
+#else
+ CFStringGetCString(cfname, mname, length * 3 + 1, CFStringGetSystemEncoding());
+#endif
+ info.name.append( (const char *)mname, strlen(mname) );
+ info.name.append( ": " );
+ CFRelease( cfname );
+ free(mname);
+
+ property.mSelector = kAudioObjectPropertyName;
+ result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &cfname );
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::probeDeviceInfo: system error (" << getErrorCode( result ) << ") getting device name.";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ //const char *name = CFStringGetCStringPtr( cfname, CFStringGetSystemEncoding() );
+ length = CFStringGetLength(cfname);
+ char *name = (char *)malloc(length * 3 + 1);
+#if defined( UNICODE ) || defined( _UNICODE )
+ CFStringGetCString(cfname, name, length * 3 + 1, kCFStringEncodingUTF8);
+#else
+ CFStringGetCString(cfname, name, length * 3 + 1, CFStringGetSystemEncoding());
+#endif
+ info.name.append( (const char *)name, strlen(name) );
+ CFRelease( cfname );
+ free(name);
+
+ // Get the output stream "configuration".
+ AudioBufferList *bufferList = nil;
+ property.mSelector = kAudioDevicePropertyStreamConfiguration;
+ property.mScope = kAudioDevicePropertyScopeOutput;
+ // property.mElement = kAudioObjectPropertyElementWildcard;
+ dataSize = 0;
+ result = AudioObjectGetPropertyDataSize( id, &property, 0, NULL, &dataSize );
+ if ( result != noErr || dataSize == 0 ) {
+ errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting output stream configuration info for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // Allocate the AudioBufferList.
+ bufferList = (AudioBufferList *) malloc( dataSize );
+ if ( bufferList == NULL ) {
+ errorText_ = "RtApiCore::getDeviceInfo: memory error allocating output AudioBufferList.";
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, bufferList );
+ if ( result != noErr || dataSize == 0 ) {
+ free( bufferList );
+ errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting output stream configuration for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // Get output channel information.
+ unsigned int i, nStreams = bufferList->mNumberBuffers;
+ for ( i=0; i<nStreams; i++ )
+ info.outputChannels += bufferList->mBuffers[i].mNumberChannels;
+ free( bufferList );
+
+ // Get the input stream "configuration".
+ property.mScope = kAudioDevicePropertyScopeInput;
+ result = AudioObjectGetPropertyDataSize( id, &property, 0, NULL, &dataSize );
+ if ( result != noErr || dataSize == 0 ) {
+ errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting input stream configuration info for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // Allocate the AudioBufferList.
+ bufferList = (AudioBufferList *) malloc( dataSize );
+ if ( bufferList == NULL ) {
+ errorText_ = "RtApiCore::getDeviceInfo: memory error allocating input AudioBufferList.";
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, bufferList );
+ if (result != noErr || dataSize == 0) {
+ free( bufferList );
+ errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting input stream configuration for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // Get input channel information.
+ nStreams = bufferList->mNumberBuffers;
+ for ( i=0; i<nStreams; i++ )
+ info.inputChannels += bufferList->mBuffers[i].mNumberChannels;
+ free( bufferList );
+
+ // If device opens for both playback and capture, we determine the channels.
+ if ( info.outputChannels > 0 && info.inputChannels > 0 )
+ info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels;
+
+ // Probe the device sample rates.
+ bool isInput = false;
+ if ( info.outputChannels == 0 ) isInput = true;
+
+ // Determine the supported sample rates.
+ property.mSelector = kAudioDevicePropertyAvailableNominalSampleRates;
+ if ( isInput == false ) property.mScope = kAudioDevicePropertyScopeOutput;
+ result = AudioObjectGetPropertyDataSize( id, &property, 0, NULL, &dataSize );
+ if ( result != kAudioHardwareNoError || dataSize == 0 ) {
+ errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting sample rate info.";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ UInt32 nRanges = dataSize / sizeof( AudioValueRange );
+ AudioValueRange rangeList[ nRanges ];
+ result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &rangeList );
+ if ( result != kAudioHardwareNoError ) {
+ errorStream_ << "RtApiCore::getDeviceInfo: system error (" << getErrorCode( result ) << ") getting sample rates.";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // The sample rate reporting mechanism is a bit of a mystery. It
+ // seems that it can either return individual rates or a range of
+ // rates. I assume that if the min / max range values are the same,
+ // then that represents a single supported rate and if the min / max
+ // range values are different, the device supports an arbitrary
+ // range of values (though there might be multiple ranges, so we'll
+ // use the most conservative range).
+ Float64 minimumRate = 1.0, maximumRate = 10000000000.0;
+ bool haveValueRange = false;
+ info.sampleRates.clear();
+ for ( UInt32 i=0; i<nRanges; i++ ) {
+ if ( rangeList[i].mMinimum == rangeList[i].mMaximum ) {
+ unsigned int tmpSr = (unsigned int) rangeList[i].mMinimum;
+ info.sampleRates.push_back( tmpSr );
+
+ if ( !info.preferredSampleRate || ( tmpSr <= 48000 && tmpSr > info.preferredSampleRate ) )
+ info.preferredSampleRate = tmpSr;
+
+ } else {
+ haveValueRange = true;
+ if ( rangeList[i].mMinimum > minimumRate ) minimumRate = rangeList[i].mMinimum;
+ if ( rangeList[i].mMaximum < maximumRate ) maximumRate = rangeList[i].mMaximum;
+ }
+ }
+
+ if ( haveValueRange ) {
+ for ( unsigned int k=0; k<MAX_SAMPLE_RATES; k++ ) {
+ if ( SAMPLE_RATES[k] >= (unsigned int) minimumRate && SAMPLE_RATES[k] <= (unsigned int) maximumRate ) {
+ info.sampleRates.push_back( SAMPLE_RATES[k] );
+
+ if ( !info.preferredSampleRate || ( SAMPLE_RATES[k] <= 48000 && SAMPLE_RATES[k] > info.preferredSampleRate ) )
+ info.preferredSampleRate = SAMPLE_RATES[k];
+ }
+ }
+ }
+
+ // Sort and remove any redundant values
+ std::sort( info.sampleRates.begin(), info.sampleRates.end() );
+ info.sampleRates.erase( unique( info.sampleRates.begin(), info.sampleRates.end() ), info.sampleRates.end() );
+
+ if ( info.sampleRates.size() == 0 ) {
+ errorStream_ << "RtApiCore::probeDeviceInfo: No supported sample rates found for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // CoreAudio always uses 32-bit floating point data for PCM streams.
+ // Thus, any other "physical" formats supported by the device are of
+ // no interest to the client.
+ info.nativeFormats = RTAUDIO_FLOAT32;
+
+ if ( info.outputChannels > 0 )
+ if ( getDefaultOutputDevice() == device ) info.isDefaultOutput = true;
+ if ( info.inputChannels > 0 )
+ if ( getDefaultInputDevice() == device ) info.isDefaultInput = true;
+
+ info.probed = true;
+ return info;
+}
+
+static OSStatus callbackHandler( AudioDeviceID inDevice,
+ const AudioTimeStamp* /*inNow*/,
+ const AudioBufferList* inInputData,
+ const AudioTimeStamp* /*inInputTime*/,
+ AudioBufferList* outOutputData,
+ const AudioTimeStamp* /*inOutputTime*/,
+ void* infoPointer )
+{
+ CallbackInfo *info = (CallbackInfo *) infoPointer;
+
+ RtApiCore *object = (RtApiCore *) info->object;
+ if ( object->callbackEvent( inDevice, inInputData, outOutputData ) == false )
+ return kAudioHardwareUnspecifiedError;
+ else
+ return kAudioHardwareNoError;
+}
+
+static OSStatus xrunListener( AudioObjectID /*inDevice*/,
+ UInt32 nAddresses,
+ const AudioObjectPropertyAddress properties[],
+ void* handlePointer )
+{
+ CoreHandle *handle = (CoreHandle *) handlePointer;
+ for ( UInt32 i=0; i<nAddresses; i++ ) {
+ if ( properties[i].mSelector == kAudioDeviceProcessorOverload ) {
+ if ( properties[i].mScope == kAudioDevicePropertyScopeInput )
+ handle->xrun[1] = true;
+ else
+ handle->xrun[0] = true;
+ }
+ }
+
+ return kAudioHardwareNoError;
+}
+
+static OSStatus rateListener( AudioObjectID inDevice,
+ UInt32 /*nAddresses*/,
+ const AudioObjectPropertyAddress /*properties*/[],
+ void* ratePointer )
+{
+ Float64 *rate = (Float64 *) ratePointer;
+ UInt32 dataSize = sizeof( Float64 );
+ AudioObjectPropertyAddress property = { kAudioDevicePropertyNominalSampleRate,
+ kAudioObjectPropertyScopeGlobal,
+ kAudioObjectPropertyElementMaster };
+ AudioObjectGetPropertyData( inDevice, &property, 0, NULL, &dataSize, rate );
+ return kAudioHardwareNoError;
+}
+
+bool RtApiCore :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options )
+{
+ // Get device ID
+ unsigned int nDevices = getDeviceCount();
+ if ( nDevices == 0 ) {
+ // This should not happen because a check is made before this function is called.
+ errorText_ = "RtApiCore::probeDeviceOpen: no devices found!";
+ return FAILURE;
+ }
+
+ if ( device >= nDevices ) {
+ // This should not happen because a check is made before this function is called.
+ errorText_ = "RtApiCore::probeDeviceOpen: device ID is invalid!";
+ return FAILURE;
+ }
+
+ AudioDeviceID deviceList[ nDevices ];
+ UInt32 dataSize = sizeof( AudioDeviceID ) * nDevices;
+ AudioObjectPropertyAddress property = { kAudioHardwarePropertyDevices,
+ kAudioObjectPropertyScopeGlobal,
+ kAudioObjectPropertyElementMaster };
+ OSStatus result = AudioObjectGetPropertyData( kAudioObjectSystemObject, &property,
+ 0, NULL, &dataSize, (void *) &deviceList );
+ if ( result != noErr ) {
+ errorText_ = "RtApiCore::probeDeviceOpen: OS-X system error getting device IDs.";
+ return FAILURE;
+ }
+
+ AudioDeviceID id = deviceList[ device ];
+
+ // Setup for stream mode.
+ bool isInput = false;
+ if ( mode == INPUT ) {
+ isInput = true;
+ property.mScope = kAudioDevicePropertyScopeInput;
+ }
+ else
+ property.mScope = kAudioDevicePropertyScopeOutput;
+
+ // Get the stream "configuration".
+ AudioBufferList *bufferList = nil;
+ dataSize = 0;
+ property.mSelector = kAudioDevicePropertyStreamConfiguration;
+ result = AudioObjectGetPropertyDataSize( id, &property, 0, NULL, &dataSize );
+ if ( result != noErr || dataSize == 0 ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting stream configuration info for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Allocate the AudioBufferList.
+ bufferList = (AudioBufferList *) malloc( dataSize );
+ if ( bufferList == NULL ) {
+ errorText_ = "RtApiCore::probeDeviceOpen: memory error allocating AudioBufferList.";
+ return FAILURE;
+ }
+
+ result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, bufferList );
+ if (result != noErr || dataSize == 0) {
+ free( bufferList );
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting stream configuration for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Search for one or more streams that contain the desired number of
+ // channels. CoreAudio devices can have an arbitrary number of
+ // streams and each stream can have an arbitrary number of channels.
+ // For each stream, a single buffer of interleaved samples is
+ // provided. RtAudio prefers the use of one stream of interleaved
+ // data or multiple consecutive single-channel streams. However, we
+ // now support multiple consecutive multi-channel streams of
+ // interleaved data as well.
+ UInt32 iStream, offsetCounter = firstChannel;
+ UInt32 nStreams = bufferList->mNumberBuffers;
+ bool monoMode = false;
+ bool foundStream = false;
+
+ // First check that the device supports the requested number of
+ // channels.
+ UInt32 deviceChannels = 0;
+ for ( iStream=0; iStream<nStreams; iStream++ )
+ deviceChannels += bufferList->mBuffers[iStream].mNumberChannels;
+
+ if ( deviceChannels < ( channels + firstChannel ) ) {
+ free( bufferList );
+ errorStream_ << "RtApiCore::probeDeviceOpen: the device (" << device << ") does not support the requested channel count.";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Look for a single stream meeting our needs.
+ UInt32 firstStream, streamCount = 1, streamChannels = 0, channelOffset = 0;
+ for ( iStream=0; iStream<nStreams; iStream++ ) {
+ streamChannels = bufferList->mBuffers[iStream].mNumberChannels;
+ if ( streamChannels >= channels + offsetCounter ) {
+ firstStream = iStream;
+ channelOffset = offsetCounter;
+ foundStream = true;
+ break;
+ }
+ if ( streamChannels > offsetCounter ) break;
+ offsetCounter -= streamChannels;
+ }
+
+ // If we didn't find a single stream above, then we should be able
+ // to meet the channel specification with multiple streams.
+ if ( foundStream == false ) {
+ monoMode = true;
+ offsetCounter = firstChannel;
+ for ( iStream=0; iStream<nStreams; iStream++ ) {
+ streamChannels = bufferList->mBuffers[iStream].mNumberChannels;
+ if ( streamChannels > offsetCounter ) break;
+ offsetCounter -= streamChannels;
+ }
+
+ firstStream = iStream;
+ channelOffset = offsetCounter;
+ Int32 channelCounter = channels + offsetCounter - streamChannels;
+
+ if ( streamChannels > 1 ) monoMode = false;
+ while ( channelCounter > 0 ) {
+ streamChannels = bufferList->mBuffers[++iStream].mNumberChannels;
+ if ( streamChannels > 1 ) monoMode = false;
+ channelCounter -= streamChannels;
+ streamCount++;
+ }
+ }
+
+ free( bufferList );
+
+ // Determine the buffer size.
+ AudioValueRange bufferRange;
+ dataSize = sizeof( AudioValueRange );
+ property.mSelector = kAudioDevicePropertyBufferFrameSizeRange;
+ result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &bufferRange );
+
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting buffer size range for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ if ( bufferRange.mMinimum > *bufferSize ) *bufferSize = (unsigned long) bufferRange.mMinimum;
+ else if ( bufferRange.mMaximum < *bufferSize ) *bufferSize = (unsigned long) bufferRange.mMaximum;
+ if ( options && options->flags & RTAUDIO_MINIMIZE_LATENCY ) *bufferSize = (unsigned long) bufferRange.mMinimum;
+
+ // Set the buffer size. For multiple streams, I'm assuming we only
+ // need to make this setting for the master channel.
+ UInt32 theSize = (UInt32) *bufferSize;
+ dataSize = sizeof( UInt32 );
+ property.mSelector = kAudioDevicePropertyBufferFrameSize;
+ result = AudioObjectSetPropertyData( id, &property, 0, NULL, dataSize, &theSize );
+
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting the buffer size for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // If attempting to setup a duplex stream, the bufferSize parameter
+ // MUST be the same in both directions!
+ *bufferSize = theSize;
+ if ( stream_.mode == OUTPUT && mode == INPUT && *bufferSize != stream_.bufferSize ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error setting buffer size for duplex stream on device (" << device << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ stream_.bufferSize = *bufferSize;
+ stream_.nBuffers = 1;
+
+ // Try to set "hog" mode ... it's not clear to me this is working.
+ if ( options && options->flags & RTAUDIO_HOG_DEVICE ) {
+ pid_t hog_pid;
+ dataSize = sizeof( hog_pid );
+ property.mSelector = kAudioDevicePropertyHogMode;
+ result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &hog_pid );
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting 'hog' state!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ if ( hog_pid != getpid() ) {
+ hog_pid = getpid();
+ result = AudioObjectSetPropertyData( id, &property, 0, NULL, dataSize, &hog_pid );
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting 'hog' state!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ }
+ }
+
+ // Check and if necessary, change the sample rate for the device.
+ Float64 nominalRate;
+ dataSize = sizeof( Float64 );
+ property.mSelector = kAudioDevicePropertyNominalSampleRate;
+ result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &nominalRate );
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting current sample rate.";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Only change the sample rate if off by more than 1 Hz.
+ if ( fabs( nominalRate - (double)sampleRate ) > 1.0 ) {
+
+ // Set a property listener for the sample rate change
+ Float64 reportedRate = 0.0;
+ AudioObjectPropertyAddress tmp = { kAudioDevicePropertyNominalSampleRate, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
+ result = AudioObjectAddPropertyListener( id, &tmp, rateListener, (void *) &reportedRate );
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting sample rate property listener for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ nominalRate = (Float64) sampleRate;
+ result = AudioObjectSetPropertyData( id, &property, 0, NULL, dataSize, &nominalRate );
+ if ( result != noErr ) {
+ AudioObjectRemovePropertyListener( id, &tmp, rateListener, (void *) &reportedRate );
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting sample rate for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Now wait until the reported nominal rate is what we just set.
+ UInt32 microCounter = 0;
+ while ( reportedRate != nominalRate ) {
+ microCounter += 5000;
+ if ( microCounter > 5000000 ) break;
+ usleep( 5000 );
+ }
+
+ // Remove the property listener.
+ AudioObjectRemovePropertyListener( id, &tmp, rateListener, (void *) &reportedRate );
+
+ if ( microCounter > 5000000 ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: timeout waiting for sample rate update for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ }
+
+ // Now set the stream format for all streams. Also, check the
+ // physical format of the device and change that if necessary.
+ AudioStreamBasicDescription description;
+ dataSize = sizeof( AudioStreamBasicDescription );
+ property.mSelector = kAudioStreamPropertyVirtualFormat;
+ result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &description );
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting stream format for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Set the sample rate and data format id. However, only make the
+ // change if the sample rate is not within 1.0 of the desired
+ // rate and the format is not linear pcm.
+ bool updateFormat = false;
+ if ( fabs( description.mSampleRate - (Float64)sampleRate ) > 1.0 ) {
+ description.mSampleRate = (Float64) sampleRate;
+ updateFormat = true;
+ }
+
+ if ( description.mFormatID != kAudioFormatLinearPCM ) {
+ description.mFormatID = kAudioFormatLinearPCM;
+ updateFormat = true;
+ }
+
+ if ( updateFormat ) {
+ result = AudioObjectSetPropertyData( id, &property, 0, NULL, dataSize, &description );
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting sample rate or data format for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ }
+
+ // Now check the physical format.
+ property.mSelector = kAudioStreamPropertyPhysicalFormat;
+ result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &description );
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting stream physical format for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ //std::cout << "Current physical stream format:" << std::endl;
+ //std::cout << " mBitsPerChan = " << description.mBitsPerChannel << std::endl;
+ //std::cout << " aligned high = " << (description.mFormatFlags & kAudioFormatFlagIsAlignedHigh) << ", isPacked = " << (description.mFormatFlags & kAudioFormatFlagIsPacked) << std::endl;
+ //std::cout << " bytesPerFrame = " << description.mBytesPerFrame << std::endl;
+ //std::cout << " sample rate = " << description.mSampleRate << std::endl;
+
+ if ( description.mFormatID != kAudioFormatLinearPCM || description.mBitsPerChannel < 16 ) {
+ description.mFormatID = kAudioFormatLinearPCM;
+ //description.mSampleRate = (Float64) sampleRate;
+ AudioStreamBasicDescription testDescription = description;
+ UInt32 formatFlags;
+
+ // We'll try higher bit rates first and then work our way down.
+ std::vector< std::pair<UInt32, UInt32> > physicalFormats;
+ formatFlags = (description.mFormatFlags | kLinearPCMFormatFlagIsFloat) & ~kLinearPCMFormatFlagIsSignedInteger;
+ physicalFormats.push_back( std::pair<Float32, UInt32>( 32, formatFlags ) );
+ formatFlags = (description.mFormatFlags | kLinearPCMFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked) & ~kLinearPCMFormatFlagIsFloat;
+ physicalFormats.push_back( std::pair<Float32, UInt32>( 32, formatFlags ) );
+ physicalFormats.push_back( std::pair<Float32, UInt32>( 24, formatFlags ) ); // 24-bit packed
+ formatFlags &= ~( kAudioFormatFlagIsPacked | kAudioFormatFlagIsAlignedHigh );
+ physicalFormats.push_back( std::pair<Float32, UInt32>( 24.2, formatFlags ) ); // 24-bit in 4 bytes, aligned low
+ formatFlags |= kAudioFormatFlagIsAlignedHigh;
+ physicalFormats.push_back( std::pair<Float32, UInt32>( 24.4, formatFlags ) ); // 24-bit in 4 bytes, aligned high
+ formatFlags = (description.mFormatFlags | kLinearPCMFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked) & ~kLinearPCMFormatFlagIsFloat;
+ physicalFormats.push_back( std::pair<Float32, UInt32>( 16, formatFlags ) );
+ physicalFormats.push_back( std::pair<Float32, UInt32>( 8, formatFlags ) );
+
+ bool setPhysicalFormat = false;
+ for( unsigned int i=0; i<physicalFormats.size(); i++ ) {
+ testDescription = description;
+ testDescription.mBitsPerChannel = (UInt32) physicalFormats[i].first;
+ testDescription.mFormatFlags = physicalFormats[i].second;
+ if ( (24 == (UInt32)physicalFormats[i].first) && ~( physicalFormats[i].second & kAudioFormatFlagIsPacked ) )
+ testDescription.mBytesPerFrame = 4 * testDescription.mChannelsPerFrame;
+ else
+ testDescription.mBytesPerFrame = testDescription.mBitsPerChannel/8 * testDescription.mChannelsPerFrame;
+ testDescription.mBytesPerPacket = testDescription.mBytesPerFrame * testDescription.mFramesPerPacket;
+ result = AudioObjectSetPropertyData( id, &property, 0, NULL, dataSize, &testDescription );
+ if ( result == noErr ) {
+ setPhysicalFormat = true;
+ //std::cout << "Updated physical stream format:" << std::endl;
+ //std::cout << " mBitsPerChan = " << testDescription.mBitsPerChannel << std::endl;
+ //std::cout << " aligned high = " << (testDescription.mFormatFlags & kAudioFormatFlagIsAlignedHigh) << ", isPacked = " << (testDescription.mFormatFlags & kAudioFormatFlagIsPacked) << std::endl;
+ //std::cout << " bytesPerFrame = " << testDescription.mBytesPerFrame << std::endl;
+ //std::cout << " sample rate = " << testDescription.mSampleRate << std::endl;
+ break;
+ }
+ }
+
+ if ( !setPhysicalFormat ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") setting physical data format for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ } // done setting virtual/physical formats.
+
+ // Get the stream / device latency.
+ UInt32 latency;
+ dataSize = sizeof( UInt32 );
+ property.mSelector = kAudioDevicePropertyLatency;
+ if ( AudioObjectHasProperty( id, &property ) == true ) {
+ result = AudioObjectGetPropertyData( id, &property, 0, NULL, &dataSize, &latency );
+ if ( result == kAudioHardwareNoError ) stream_.latency[ mode ] = latency;
+ else {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error (" << getErrorCode( result ) << ") getting device latency for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ }
+ }
+
+ // Byte-swapping: According to AudioHardware.h, the stream data will
+ // always be presented in native-endian format, so we should never
+ // need to byte swap.
+ stream_.doByteSwap[mode] = false;
+
+ // From the CoreAudio documentation, PCM data must be supplied as
+ // 32-bit floats.
+ stream_.userFormat = format;
+ stream_.deviceFormat[mode] = RTAUDIO_FLOAT32;
+
+ if ( streamCount == 1 )
+ stream_.nDeviceChannels[mode] = description.mChannelsPerFrame;
+ else // multiple streams
+ stream_.nDeviceChannels[mode] = channels;
+ stream_.nUserChannels[mode] = channels;
+ stream_.channelOffset[mode] = channelOffset; // offset within a CoreAudio stream
+ if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false;
+ else stream_.userInterleaved = true;
+ stream_.deviceInterleaved[mode] = true;
+ if ( monoMode == true ) stream_.deviceInterleaved[mode] = false;
+
+ // Set flags for buffer conversion.
+ stream_.doConvertBuffer[mode] = false;
+ if ( stream_.userFormat != stream_.deviceFormat[mode] )
+ stream_.doConvertBuffer[mode] = true;
+ if ( stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode] )
+ stream_.doConvertBuffer[mode] = true;
+ if ( streamCount == 1 ) {
+ if ( stream_.nUserChannels[mode] > 1 &&
+ stream_.userInterleaved != stream_.deviceInterleaved[mode] )
+ stream_.doConvertBuffer[mode] = true;
+ }
+ else if ( monoMode && stream_.userInterleaved )
+ stream_.doConvertBuffer[mode] = true;
+
+ // Allocate our CoreHandle structure for the stream.
+ CoreHandle *handle = 0;
+ if ( stream_.apiHandle == 0 ) {
+ try {
+ handle = new CoreHandle;
+ }
+ catch ( std::bad_alloc& ) {
+ errorText_ = "RtApiCore::probeDeviceOpen: error allocating CoreHandle memory.";
+ goto error;
+ }
+
+ if ( pthread_cond_init( &handle->condition, NULL ) ) {
+ errorText_ = "RtApiCore::probeDeviceOpen: error initializing pthread condition variable.";
+ goto error;
+ }
+ stream_.apiHandle = (void *) handle;
+ }
+ else
+ handle = (CoreHandle *) stream_.apiHandle;
+ handle->iStream[mode] = firstStream;
+ handle->nStreams[mode] = streamCount;
+ handle->id[mode] = id;
+
+ // Allocate necessary internal buffers.
+ unsigned long bufferBytes;
+ bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
+ // stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
+ stream_.userBuffer[mode] = (char *) malloc( bufferBytes * sizeof(char) );
+ memset( stream_.userBuffer[mode], 0, bufferBytes * sizeof(char) );
+ if ( stream_.userBuffer[mode] == NULL ) {
+ errorText_ = "RtApiCore::probeDeviceOpen: error allocating user buffer memory.";
+ goto error;
+ }
+
+ // If possible, we will make use of the CoreAudio stream buffers as
+ // "device buffers". However, we can't do this if using multiple
+ // streams.
+ if ( stream_.doConvertBuffer[mode] && handle->nStreams[mode] > 1 ) {
+
+ bool makeBuffer = true;
+ bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] );
+ if ( mode == INPUT ) {
+ if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) {
+ unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
+ if ( bufferBytes <= bytesOut ) makeBuffer = false;
+ }
+ }
+
+ if ( makeBuffer ) {
+ bufferBytes *= *bufferSize;
+ if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
+ stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
+ if ( stream_.deviceBuffer == NULL ) {
+ errorText_ = "RtApiCore::probeDeviceOpen: error allocating device buffer memory.";
+ goto error;
+ }
+ }
+ }
+
+ stream_.sampleRate = sampleRate;
+ stream_.device[mode] = device;
+ stream_.state = STREAM_STOPPED;
+ stream_.callbackInfo.object = (void *) this;
+
+ // Setup the buffer conversion information structure.
+ if ( stream_.doConvertBuffer[mode] ) {
+ if ( streamCount > 1 ) setConvertInfo( mode, 0 );
+ else setConvertInfo( mode, channelOffset );
+ }
+
+ if ( mode == INPUT && stream_.mode == OUTPUT && stream_.device[0] == device )
+ // Only one callback procedure per device.
+ stream_.mode = DUPLEX;
+ else {
+#if defined( MAC_OS_X_VERSION_10_5 ) && ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 )
+ result = AudioDeviceCreateIOProcID( id, callbackHandler, (void *) &stream_.callbackInfo, &handle->procId[mode] );
+#else
+ // deprecated in favor of AudioDeviceCreateIOProcID()
+ result = AudioDeviceAddIOProc( id, callbackHandler, (void *) &stream_.callbackInfo );
+#endif
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::probeDeviceOpen: system error setting callback for device (" << device << ").";
+ errorText_ = errorStream_.str();
+ goto error;
+ }
+ if ( stream_.mode == OUTPUT && mode == INPUT )
+ stream_.mode = DUPLEX;
+ else
+ stream_.mode = mode;
+ }
+
+ // Setup the device property listener for over/underload.
+ property.mSelector = kAudioDeviceProcessorOverload;
+ property.mScope = kAudioObjectPropertyScopeGlobal;
+ result = AudioObjectAddPropertyListener( id, &property, xrunListener, (void *) handle );
+
+ return SUCCESS;
+
+ error:
+ if ( handle ) {
+ pthread_cond_destroy( &handle->condition );
+ delete handle;
+ stream_.apiHandle = 0;
+ }
+
+ for ( int i=0; i<2; i++ ) {
+ if ( stream_.userBuffer[i] ) {
+ free( stream_.userBuffer[i] );
+ stream_.userBuffer[i] = 0;
+ }
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+
+ stream_.state = STREAM_CLOSED;
+ return FAILURE;
+}
+
+void RtApiCore :: closeStream( void )
+{
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiCore::closeStream(): no open stream to close!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ CoreHandle *handle = (CoreHandle *) stream_.apiHandle;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+ if (handle) {
+ AudioObjectPropertyAddress property = { kAudioHardwarePropertyDevices,
+ kAudioObjectPropertyScopeGlobal,
+ kAudioObjectPropertyElementMaster };
+
+ property.mSelector = kAudioDeviceProcessorOverload;
+ property.mScope = kAudioObjectPropertyScopeGlobal;
+ if (AudioObjectRemovePropertyListener( handle->id[0], &property, xrunListener, (void *) handle ) != noErr) {
+ errorText_ = "RtApiCore::closeStream(): error removing property listener!";
+ error( RtAudioError::WARNING );
+ }
+ }
+ if ( stream_.state == STREAM_RUNNING )
+ AudioDeviceStop( handle->id[0], callbackHandler );
+#if defined( MAC_OS_X_VERSION_10_5 ) && ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 )
+ AudioDeviceDestroyIOProcID( handle->id[0], handle->procId[0] );
+#else
+ // deprecated in favor of AudioDeviceDestroyIOProcID()
+ AudioDeviceRemoveIOProc( handle->id[0], callbackHandler );
+#endif
+ }
+
+ if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1] ) ) {
+ if (handle) {
+ AudioObjectPropertyAddress property = { kAudioHardwarePropertyDevices,
+ kAudioObjectPropertyScopeGlobal,
+ kAudioObjectPropertyElementMaster };
+
+ property.mSelector = kAudioDeviceProcessorOverload;
+ property.mScope = kAudioObjectPropertyScopeGlobal;
+ if (AudioObjectRemovePropertyListener( handle->id[1], &property, xrunListener, (void *) handle ) != noErr) {
+ errorText_ = "RtApiCore::closeStream(): error removing property listener!";
+ error( RtAudioError::WARNING );
+ }
+ }
+ if ( stream_.state == STREAM_RUNNING )
+ AudioDeviceStop( handle->id[1], callbackHandler );
+#if defined( MAC_OS_X_VERSION_10_5 ) && ( MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5 )
+ AudioDeviceDestroyIOProcID( handle->id[1], handle->procId[1] );
+#else
+ // deprecated in favor of AudioDeviceDestroyIOProcID()
+ AudioDeviceRemoveIOProc( handle->id[1], callbackHandler );
+#endif
+ }
+
+ for ( int i=0; i<2; i++ ) {
+ if ( stream_.userBuffer[i] ) {
+ free( stream_.userBuffer[i] );
+ stream_.userBuffer[i] = 0;
+ }
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+
+ // Destroy pthread condition variable.
+ pthread_cond_destroy( &handle->condition );
+ delete handle;
+ stream_.apiHandle = 0;
+
+ stream_.mode = UNINITIALIZED;
+ stream_.state = STREAM_CLOSED;
+}
+
+void RtApiCore :: startStream( void )
+{
+ verifyStream();
+ if ( stream_.state == STREAM_RUNNING ) {
+ errorText_ = "RtApiCore::startStream(): the stream is already running!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ #if defined( HAVE_GETTIMEOFDAY )
+ gettimeofday( &stream_.lastTickTimestamp, NULL );
+ #endif
+
+ OSStatus result = noErr;
+ CoreHandle *handle = (CoreHandle *) stream_.apiHandle;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+
+ result = AudioDeviceStart( handle->id[0], callbackHandler );
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::startStream: system error (" << getErrorCode( result ) << ") starting callback procedure on device (" << stream_.device[0] << ").";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+
+ if ( stream_.mode == INPUT ||
+ ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1] ) ) {
+
+ result = AudioDeviceStart( handle->id[1], callbackHandler );
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::startStream: system error starting input callback procedure on device (" << stream_.device[1] << ").";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+
+ handle->drainCounter = 0;
+ handle->internalDrain = false;
+ stream_.state = STREAM_RUNNING;
+
+ unlock:
+ if ( result == noErr ) return;
+ error( RtAudioError::SYSTEM_ERROR );
+}
+
+void RtApiCore :: stopStream( void )
+{
+ verifyStream();
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiCore::stopStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ OSStatus result = noErr;
+ CoreHandle *handle = (CoreHandle *) stream_.apiHandle;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+
+ if ( handle->drainCounter == 0 ) {
+ handle->drainCounter = 2;
+ pthread_cond_wait( &handle->condition, &stream_.mutex ); // block until signaled
+ }
+
+ result = AudioDeviceStop( handle->id[0], callbackHandler );
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::stopStream: system error (" << getErrorCode( result ) << ") stopping callback procedure on device (" << stream_.device[0] << ").";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+
+ if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && stream_.device[0] != stream_.device[1] ) ) {
+
+ result = AudioDeviceStop( handle->id[1], callbackHandler );
+ if ( result != noErr ) {
+ errorStream_ << "RtApiCore::stopStream: system error (" << getErrorCode( result ) << ") stopping input callback procedure on device (" << stream_.device[1] << ").";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+
+ stream_.state = STREAM_STOPPED;
+
+ unlock:
+ if ( result == noErr ) return;
+ error( RtAudioError::SYSTEM_ERROR );
+}
+
+void RtApiCore :: abortStream( void )
+{
+ verifyStream();
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiCore::abortStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ CoreHandle *handle = (CoreHandle *) stream_.apiHandle;
+ handle->drainCounter = 2;
+
+ stopStream();
+}
+
+// This function will be called by a spawned thread when the user
+// callback function signals that the stream should be stopped or
+// aborted. It is better to handle it this way because the
+// callbackEvent() function probably should return before the AudioDeviceStop()
+// function is called.
+static void *coreStopStream( void *ptr )
+{
+ CallbackInfo *info = (CallbackInfo *) ptr;
+ RtApiCore *object = (RtApiCore *) info->object;
+
+ object->stopStream();
+ pthread_exit( NULL );
+}
+
+bool RtApiCore :: callbackEvent( AudioDeviceID deviceId,
+ const AudioBufferList *inBufferList,
+ const AudioBufferList *outBufferList )
+{
+ if ( stream_.state == STREAM_STOPPED || stream_.state == STREAM_STOPPING ) return SUCCESS;
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiCore::callbackEvent(): the stream is closed ... this shouldn't happen!";
+ error( RtAudioError::WARNING );
+ return FAILURE;
+ }
+
+ CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo;
+ CoreHandle *handle = (CoreHandle *) stream_.apiHandle;
+
+ // Check if we were draining the stream and signal is finished.
+ if ( handle->drainCounter > 3 ) {
+ ThreadHandle threadId;
+
+ stream_.state = STREAM_STOPPING;
+ if ( handle->internalDrain == true )
+ pthread_create( &threadId, NULL, coreStopStream, info );
+ else // external call to stopStream()
+ pthread_cond_signal( &handle->condition );
+ return SUCCESS;
+ }
+
+ AudioDeviceID outputDevice = handle->id[0];
+
+ // Invoke user callback to get fresh output data UNLESS we are
+ // draining stream or duplex mode AND the input/output devices are
+ // different AND this function is called for the input device.
+ if ( handle->drainCounter == 0 && ( stream_.mode != DUPLEX || deviceId == outputDevice ) ) {
+ RtAudioCallback callback = (RtAudioCallback) info->callback;
+ double streamTime = getStreamTime();
+ RtAudioStreamStatus status = 0;
+ if ( stream_.mode != INPUT && handle->xrun[0] == true ) {
+ status |= RTAUDIO_OUTPUT_UNDERFLOW;
+ handle->xrun[0] = false;
+ }
+ if ( stream_.mode != OUTPUT && handle->xrun[1] == true ) {
+ status |= RTAUDIO_INPUT_OVERFLOW;
+ handle->xrun[1] = false;
+ }
+
+ int cbReturnValue = callback( stream_.userBuffer[0], stream_.userBuffer[1],
+ stream_.bufferSize, streamTime, status, info->userData );
+ if ( cbReturnValue == 2 ) {
+ stream_.state = STREAM_STOPPING;
+ handle->drainCounter = 2;
+ abortStream();
+ return SUCCESS;
+ }
+ else if ( cbReturnValue == 1 ) {
+ handle->drainCounter = 1;
+ handle->internalDrain = true;
+ }
+ }
+
+ if ( stream_.mode == OUTPUT || ( stream_.mode == DUPLEX && deviceId == outputDevice ) ) {
+
+ if ( handle->drainCounter > 1 ) { // write zeros to the output stream
+
+ if ( handle->nStreams[0] == 1 ) {
+ memset( outBufferList->mBuffers[handle->iStream[0]].mData,
+ 0,
+ outBufferList->mBuffers[handle->iStream[0]].mDataByteSize );
+ }
+ else { // fill multiple streams with zeros
+ for ( unsigned int i=0; i<handle->nStreams[0]; i++ ) {
+ memset( outBufferList->mBuffers[handle->iStream[0]+i].mData,
+ 0,
+ outBufferList->mBuffers[handle->iStream[0]+i].mDataByteSize );
+ }
+ }
+ }
+ else if ( handle->nStreams[0] == 1 ) {
+ if ( stream_.doConvertBuffer[0] ) { // convert directly to CoreAudio stream buffer
+ convertBuffer( (char *) outBufferList->mBuffers[handle->iStream[0]].mData,
+ stream_.userBuffer[0], stream_.convertInfo[0] );
+ }
+ else { // copy from user buffer
+ memcpy( outBufferList->mBuffers[handle->iStream[0]].mData,
+ stream_.userBuffer[0],
+ outBufferList->mBuffers[handle->iStream[0]].mDataByteSize );
+ }
+ }
+ else { // fill multiple streams
+ Float32 *inBuffer = (Float32 *) stream_.userBuffer[0];
+ if ( stream_.doConvertBuffer[0] ) {
+ convertBuffer( stream_.deviceBuffer, stream_.userBuffer[0], stream_.convertInfo[0] );
+ inBuffer = (Float32 *) stream_.deviceBuffer;
+ }
+
+ if ( stream_.deviceInterleaved[0] == false ) { // mono mode
+ UInt32 bufferBytes = outBufferList->mBuffers[handle->iStream[0]].mDataByteSize;
+ for ( unsigned int i=0; i<stream_.nUserChannels[0]; i++ ) {
+ memcpy( outBufferList->mBuffers[handle->iStream[0]+i].mData,
+ (void *)&inBuffer[i*stream_.bufferSize], bufferBytes );
+ }
+ }
+ else { // fill multiple multi-channel streams with interleaved data
+ UInt32 streamChannels, channelsLeft, inJump, outJump, inOffset;
+ Float32 *out, *in;
+
+ bool inInterleaved = ( stream_.userInterleaved ) ? true : false;
+ UInt32 inChannels = stream_.nUserChannels[0];
+ if ( stream_.doConvertBuffer[0] ) {
+ inInterleaved = true; // device buffer will always be interleaved for nStreams > 1 and not mono mode
+ inChannels = stream_.nDeviceChannels[0];
+ }
+
+ if ( inInterleaved ) inOffset = 1;
+ else inOffset = stream_.bufferSize;
+
+ channelsLeft = inChannels;
+ for ( unsigned int i=0; i<handle->nStreams[0]; i++ ) {
+ in = inBuffer;
+ out = (Float32 *) outBufferList->mBuffers[handle->iStream[0]+i].mData;
+ streamChannels = outBufferList->mBuffers[handle->iStream[0]+i].mNumberChannels;
+
+ outJump = 0;
+ // Account for possible channel offset in first stream
+ if ( i == 0 && stream_.channelOffset[0] > 0 ) {
+ streamChannels -= stream_.channelOffset[0];
+ outJump = stream_.channelOffset[0];
+ out += outJump;
+ }
+
+ // Account for possible unfilled channels at end of the last stream
+ if ( streamChannels > channelsLeft ) {
+ outJump = streamChannels - channelsLeft;
+ streamChannels = channelsLeft;
+ }
+
+ // Determine input buffer offsets and skips
+ if ( inInterleaved ) {
+ inJump = inChannels;
+ in += inChannels - channelsLeft;
+ }
+ else {
+ inJump = 1;
+ in += (inChannels - channelsLeft) * inOffset;
+ }
+
+ for ( unsigned int i=0; i<stream_.bufferSize; i++ ) {
+ for ( unsigned int j=0; j<streamChannels; j++ ) {
+ *out++ = in[j*inOffset];
+ }
+ out += outJump;
+ in += inJump;
+ }
+ channelsLeft -= streamChannels;
+ }
+ }
+ }
+ }
+
+ // Don't bother draining input
+ if ( handle->drainCounter ) {
+ handle->drainCounter++;
+ goto unlock;
+ }
+
+ AudioDeviceID inputDevice;
+ inputDevice = handle->id[1];
+ if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && deviceId == inputDevice ) ) {
+
+ if ( handle->nStreams[1] == 1 ) {
+ if ( stream_.doConvertBuffer[1] ) { // convert directly from CoreAudio stream buffer
+ convertBuffer( stream_.userBuffer[1],
+ (char *) inBufferList->mBuffers[handle->iStream[1]].mData,
+ stream_.convertInfo[1] );
+ }
+ else { // copy to user buffer
+ memcpy( stream_.userBuffer[1],
+ inBufferList->mBuffers[handle->iStream[1]].mData,
+ inBufferList->mBuffers[handle->iStream[1]].mDataByteSize );
+ }
+ }
+ else { // read from multiple streams
+ Float32 *outBuffer = (Float32 *) stream_.userBuffer[1];
+ if ( stream_.doConvertBuffer[1] ) outBuffer = (Float32 *) stream_.deviceBuffer;
+
+ if ( stream_.deviceInterleaved[1] == false ) { // mono mode
+ UInt32 bufferBytes = inBufferList->mBuffers[handle->iStream[1]].mDataByteSize;
+ for ( unsigned int i=0; i<stream_.nUserChannels[1]; i++ ) {
+ memcpy( (void *)&outBuffer[i*stream_.bufferSize],
+ inBufferList->mBuffers[handle->iStream[1]+i].mData, bufferBytes );
+ }
+ }
+ else { // read from multiple multi-channel streams
+ UInt32 streamChannels, channelsLeft, inJump, outJump, outOffset;
+ Float32 *out, *in;
+
+ bool outInterleaved = ( stream_.userInterleaved ) ? true : false;
+ UInt32 outChannels = stream_.nUserChannels[1];
+ if ( stream_.doConvertBuffer[1] ) {
+ outInterleaved = true; // device buffer will always be interleaved for nStreams > 1 and not mono mode
+ outChannels = stream_.nDeviceChannels[1];
+ }
+
+ if ( outInterleaved ) outOffset = 1;
+ else outOffset = stream_.bufferSize;
+
+ channelsLeft = outChannels;
+ for ( unsigned int i=0; i<handle->nStreams[1]; i++ ) {
+ out = outBuffer;
+ in = (Float32 *) inBufferList->mBuffers[handle->iStream[1]+i].mData;
+ streamChannels = inBufferList->mBuffers[handle->iStream[1]+i].mNumberChannels;
+
+ inJump = 0;
+ // Account for possible channel offset in first stream
+ if ( i == 0 && stream_.channelOffset[1] > 0 ) {
+ streamChannels -= stream_.channelOffset[1];
+ inJump = stream_.channelOffset[1];
+ in += inJump;
+ }
+
+ // Account for possible unread channels at end of the last stream
+ if ( streamChannels > channelsLeft ) {
+ inJump = streamChannels - channelsLeft;
+ streamChannels = channelsLeft;
+ }
+
+ // Determine output buffer offsets and skips
+ if ( outInterleaved ) {
+ outJump = outChannels;
+ out += outChannels - channelsLeft;
+ }
+ else {
+ outJump = 1;
+ out += (outChannels - channelsLeft) * outOffset;
+ }
+
+ for ( unsigned int i=0; i<stream_.bufferSize; i++ ) {
+ for ( unsigned int j=0; j<streamChannels; j++ ) {
+ out[j*outOffset] = *in++;
+ }
+ out += outJump;
+ in += inJump;
+ }
+ channelsLeft -= streamChannels;
+ }
+ }
+
+ if ( stream_.doConvertBuffer[1] ) { // convert from our internal "device" buffer
+ convertBuffer( stream_.userBuffer[1],
+ stream_.deviceBuffer,
+ stream_.convertInfo[1] );
+ }
+ }
+ }
+
+ unlock:
+ //MUTEX_UNLOCK( &stream_.mutex );
+
+ // Make sure to only tick duplex stream time once if using two devices
+ if ( stream_.mode != DUPLEX || (stream_.mode == DUPLEX && handle->id[0] != handle->id[1] && deviceId == handle->id[0] ) )
+ RtApi::tickStreamTime();
+
+ return SUCCESS;
+}
+
+const char* RtApiCore :: getErrorCode( OSStatus code )
+{
+ switch( code ) {
+
+ case kAudioHardwareNotRunningError:
+ return "kAudioHardwareNotRunningError";
+
+ case kAudioHardwareUnspecifiedError:
+ return "kAudioHardwareUnspecifiedError";
+
+ case kAudioHardwareUnknownPropertyError:
+ return "kAudioHardwareUnknownPropertyError";
+
+ case kAudioHardwareBadPropertySizeError:
+ return "kAudioHardwareBadPropertySizeError";
+
+ case kAudioHardwareIllegalOperationError:
+ return "kAudioHardwareIllegalOperationError";
+
+ case kAudioHardwareBadObjectError:
+ return "kAudioHardwareBadObjectError";
+
+ case kAudioHardwareBadDeviceError:
+ return "kAudioHardwareBadDeviceError";
+
+ case kAudioHardwareBadStreamError:
+ return "kAudioHardwareBadStreamError";
+
+ case kAudioHardwareUnsupportedOperationError:
+ return "kAudioHardwareUnsupportedOperationError";
+
+ case kAudioDeviceUnsupportedFormatError:
+ return "kAudioDeviceUnsupportedFormatError";
+
+ case kAudioDevicePermissionsError:
+ return "kAudioDevicePermissionsError";
+
+ default:
+ return "CoreAudio unknown error";
+ }
+}
+
+ //******************** End of __MACOSX_CORE__ *********************//
+#endif
+
+#if defined(__UNIX_JACK__)
+
+// JACK is a low-latency audio server, originally written for the
+// GNU/Linux operating system and now also ported to OS-X. It can
+// connect a number of different applications to an audio device, as
+// well as allowing them to share audio between themselves.
+//
+// When using JACK with RtAudio, "devices" refer to JACK clients that
+// have ports connected to the server. The JACK server is typically
+// started in a terminal as follows:
+//
+// .jackd -d alsa -d hw:0
+//
+// or through an interface program such as qjackctl. Many of the
+// parameters normally set for a stream are fixed by the JACK server
+// and can be specified when the JACK server is started. In
+// particular,
+//
+// .jackd -d alsa -d hw:0 -r 44100 -p 512 -n 4
+//
+// specifies a sample rate of 44100 Hz, a buffer size of 512 sample
+// frames, and number of buffers = 4. Once the server is running, it
+// is not possible to override these values. If the values are not
+// specified in the command-line, the JACK server uses default values.
+//
+// The JACK server does not have to be running when an instance of
+// RtApiJack is created, though the function getDeviceCount() will
+// report 0 devices found until JACK has been started. When no
+// devices are available (i.e., the JACK server is not running), a
+// stream cannot be opened.
+
+#include <jack/jack.h>
+#include <unistd.h>
+#include <cstdio>
+
+// A structure to hold various information related to the Jack API
+// implementation.
+struct JackHandle {
+ jack_client_t *client;
+ jack_port_t **ports[2];
+ std::string deviceName[2];
+ bool xrun[2];
+ pthread_cond_t condition;
+ int drainCounter; // Tracks callback counts when draining
+ bool internalDrain; // Indicates if stop is initiated from callback or not.
+
+ JackHandle()
+ :client(0), drainCounter(0), internalDrain(false) { ports[0] = 0; ports[1] = 0; xrun[0] = false; xrun[1] = false; }
+};
+
+#if !defined(__RTAUDIO_DEBUG__)
+static void jackSilentError( const char * ) {};
+#endif
+
+RtApiJack :: RtApiJack()
+ :shouldAutoconnect_(true) {
+ // Nothing to do here.
+#if !defined(__RTAUDIO_DEBUG__)
+ // Turn off Jack's internal error reporting.
+ jack_set_error_function( &jackSilentError );
+#endif
+}
+
+RtApiJack :: ~RtApiJack()
+{
+ if ( stream_.state != STREAM_CLOSED ) closeStream();
+}
+
+unsigned int RtApiJack :: getDeviceCount( void )
+{
+ // See if we can become a jack client.
+ jack_options_t options = (jack_options_t) ( JackNoStartServer ); //JackNullOption;
+ jack_status_t *status = NULL;
+ jack_client_t *client = jack_client_open( "RtApiJackCount", options, status );
+ if ( client == 0 ) return 0;
+
+ const char **ports;
+ std::string port, previousPort;
+ unsigned int nChannels = 0, nDevices = 0;
+ ports = jack_get_ports( client, NULL, JACK_DEFAULT_AUDIO_TYPE, 0 );
+ if ( ports ) {
+ // Parse the port names up to the first colon (:).
+ size_t iColon = 0;
+ do {
+ port = (char *) ports[ nChannels ];
+ iColon = port.find(":");
+ if ( iColon != std::string::npos ) {
+ port = port.substr( 0, iColon + 1 );
+ if ( port != previousPort ) {
+ nDevices++;
+ previousPort = port;
+ }
+ }
+ } while ( ports[++nChannels] );
+ free( ports );
+ }
+
+ jack_client_close( client );
+ return nDevices;
+}
+
+RtAudio::DeviceInfo RtApiJack :: getDeviceInfo( unsigned int device )
+{
+ RtAudio::DeviceInfo info;
+ info.probed = false;
+
+ jack_options_t options = (jack_options_t) ( JackNoStartServer ); //JackNullOption
+ jack_status_t *status = NULL;
+ jack_client_t *client = jack_client_open( "RtApiJackInfo", options, status );
+ if ( client == 0 ) {
+ errorText_ = "RtApiJack::getDeviceInfo: Jack server not found or connection error!";
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ const char **ports;
+ std::string port, previousPort;
+ unsigned int nPorts = 0, nDevices = 0;
+ ports = jack_get_ports( client, NULL, JACK_DEFAULT_AUDIO_TYPE, 0 );
+ if ( ports ) {
+ // Parse the port names up to the first colon (:).
+ size_t iColon = 0;
+ do {
+ port = (char *) ports[ nPorts ];
+ iColon = port.find(":");
+ if ( iColon != std::string::npos ) {
+ port = port.substr( 0, iColon );
+ if ( port != previousPort ) {
+ if ( nDevices == device ) info.name = port;
+ nDevices++;
+ previousPort = port;
+ }
+ }
+ } while ( ports[++nPorts] );
+ free( ports );
+ }
+
+ if ( device >= nDevices ) {
+ jack_client_close( client );
+ errorText_ = "RtApiJack::getDeviceInfo: device ID is invalid!";
+ error( RtAudioError::INVALID_USE );
+ return info;
+ }
+
+ // Get the current jack server sample rate.
+ info.sampleRates.clear();
+
+ info.preferredSampleRate = jack_get_sample_rate( client );
+ info.sampleRates.push_back( info.preferredSampleRate );
+
+ // Count the available ports containing the client name as device
+ // channels. Jack "input ports" equal RtAudio output channels.
+ unsigned int nChannels = 0;
+ ports = jack_get_ports( client, info.name.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput );
+ if ( ports ) {
+ while ( ports[ nChannels ] ) nChannels++;
+ free( ports );
+ info.outputChannels = nChannels;
+ }
+
+ // Jack "output ports" equal RtAudio input channels.
+ nChannels = 0;
+ ports = jack_get_ports( client, info.name.c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput );
+ if ( ports ) {
+ while ( ports[ nChannels ] ) nChannels++;
+ free( ports );
+ info.inputChannels = nChannels;
+ }
+
+ if ( info.outputChannels == 0 && info.inputChannels == 0 ) {
+ jack_client_close(client);
+ errorText_ = "RtApiJack::getDeviceInfo: error determining Jack input/output channels!";
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // If device opens for both playback and capture, we determine the channels.
+ if ( info.outputChannels > 0 && info.inputChannels > 0 )
+ info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels;
+
+ // Jack always uses 32-bit floats.
+ info.nativeFormats = RTAUDIO_FLOAT32;
+
+ // Jack doesn't provide default devices so we'll use the first available one.
+ if ( device == 0 && info.outputChannels > 0 )
+ info.isDefaultOutput = true;
+ if ( device == 0 && info.inputChannels > 0 )
+ info.isDefaultInput = true;
+
+ jack_client_close(client);
+ info.probed = true;
+ return info;
+}
+
+static int jackCallbackHandler( jack_nframes_t nframes, void *infoPointer )
+{
+ CallbackInfo *info = (CallbackInfo *) infoPointer;
+
+ RtApiJack *object = (RtApiJack *) info->object;
+ if ( object->callbackEvent( (unsigned long) nframes ) == false ) return 1;
+
+ return 0;
+}
+
+// This function will be called by a spawned thread when the Jack
+// server signals that it is shutting down. It is necessary to handle
+// it this way because the jackShutdown() function must return before
+// the jack_deactivate() function (in closeStream()) will return.
+static void *jackCloseStream( void *ptr )
+{
+ CallbackInfo *info = (CallbackInfo *) ptr;
+ RtApiJack *object = (RtApiJack *) info->object;
+
+ object->closeStream();
+
+ pthread_exit( NULL );
+}
+static void jackShutdown( void *infoPointer )
+{
+ CallbackInfo *info = (CallbackInfo *) infoPointer;
+ RtApiJack *object = (RtApiJack *) info->object;
+
+ // Check current stream state. If stopped, then we'll assume this
+ // was called as a result of a call to RtApiJack::stopStream (the
+ // deactivation of a client handle causes this function to be called).
+ // If not, we'll assume the Jack server is shutting down or some
+ // other problem occurred and we should close the stream.
+ if ( object->isStreamRunning() == false ) return;
+
+ ThreadHandle threadId;
+ pthread_create( &threadId, NULL, jackCloseStream, info );
+ std::cerr << "\nRtApiJack: the Jack server is shutting down this client ... stream stopped and closed!!\n" << std::endl;
+}
+
+static int jackXrun( void *infoPointer )
+{
+ JackHandle *handle = *((JackHandle **) infoPointer);
+
+ if ( handle->ports[0] ) handle->xrun[0] = true;
+ if ( handle->ports[1] ) handle->xrun[1] = true;
+
+ return 0;
+}
+
+bool RtApiJack :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options )
+{
+ JackHandle *handle = (JackHandle *) stream_.apiHandle;
+
+ // Look for jack server and try to become a client (only do once per stream).
+ jack_client_t *client = 0;
+ if ( mode == OUTPUT || ( mode == INPUT && stream_.mode != OUTPUT ) ) {
+ jack_options_t jackoptions = (jack_options_t) ( JackNoStartServer ); //JackNullOption;
+ jack_status_t *status = NULL;
+ if ( options && !options->streamName.empty() )
+ client = jack_client_open( options->streamName.c_str(), jackoptions, status );
+ else
+ client = jack_client_open( "RtApiJack", jackoptions, status );
+ if ( client == 0 ) {
+ errorText_ = "RtApiJack::probeDeviceOpen: Jack server not found or connection error!";
+ error( RtAudioError::WARNING );
+ return FAILURE;
+ }
+ }
+ else {
+ // The handle must have been created on an earlier pass.
+ client = handle->client;
+ }
+
+ const char **ports;
+ std::string port, previousPort, deviceName;
+ unsigned int nPorts = 0, nDevices = 0;
+ ports = jack_get_ports( client, NULL, JACK_DEFAULT_AUDIO_TYPE, 0 );
+ if ( ports ) {
+ // Parse the port names up to the first colon (:).
+ size_t iColon = 0;
+ do {
+ port = (char *) ports[ nPorts ];
+ iColon = port.find(":");
+ if ( iColon != std::string::npos ) {
+ port = port.substr( 0, iColon );
+ if ( port != previousPort ) {
+ if ( nDevices == device ) deviceName = port;
+ nDevices++;
+ previousPort = port;
+ }
+ }
+ } while ( ports[++nPorts] );
+ free( ports );
+ }
+
+ if ( device >= nDevices ) {
+ errorText_ = "RtApiJack::probeDeviceOpen: device ID is invalid!";
+ return FAILURE;
+ }
+
+ unsigned long flag = JackPortIsInput;
+ if ( mode == INPUT ) flag = JackPortIsOutput;
+
+ if ( ! (options && (options->flags & RTAUDIO_JACK_DONT_CONNECT)) ) {
+ // Count the available ports containing the client name as device
+ // channels. Jack "input ports" equal RtAudio output channels.
+ unsigned int nChannels = 0;
+ ports = jack_get_ports( client, deviceName.c_str(), JACK_DEFAULT_AUDIO_TYPE, flag );
+ if ( ports ) {
+ while ( ports[ nChannels ] ) nChannels++;
+ free( ports );
+ }
+ // Compare the jack ports for specified client to the requested number of channels.
+ if ( nChannels < (channels + firstChannel) ) {
+ errorStream_ << "RtApiJack::probeDeviceOpen: requested number of channels (" << channels << ") + offset (" << firstChannel << ") not found for specified device (" << device << ":" << deviceName << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ }
+
+ // Check the jack server sample rate.
+ unsigned int jackRate = jack_get_sample_rate( client );
+ if ( sampleRate != jackRate ) {
+ jack_client_close( client );
+ errorStream_ << "RtApiJack::probeDeviceOpen: the requested sample rate (" << sampleRate << ") is different than the JACK server rate (" << jackRate << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ stream_.sampleRate = jackRate;
+
+ // Get the latency of the JACK port.
+ ports = jack_get_ports( client, deviceName.c_str(), JACK_DEFAULT_AUDIO_TYPE, flag );
+ if ( ports[ firstChannel ] ) {
+ // Added by Ge Wang
+ jack_latency_callback_mode_t cbmode = (mode == INPUT ? JackCaptureLatency : JackPlaybackLatency);
+ // the range (usually the min and max are equal)
+ jack_latency_range_t latrange; latrange.min = latrange.max = 0;
+ // get the latency range
+ jack_port_get_latency_range( jack_port_by_name( client, ports[firstChannel] ), cbmode, &latrange );
+ // be optimistic, use the min!
+ stream_.latency[mode] = latrange.min;
+ //stream_.latency[mode] = jack_port_get_latency( jack_port_by_name( client, ports[ firstChannel ] ) );
+ }
+ free( ports );
+
+ // The jack server always uses 32-bit floating-point data.
+ stream_.deviceFormat[mode] = RTAUDIO_FLOAT32;
+ stream_.userFormat = format;
+
+ if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false;
+ else stream_.userInterleaved = true;
+
+ // Jack always uses non-interleaved buffers.
+ stream_.deviceInterleaved[mode] = false;
+
+ // Jack always provides host byte-ordered data.
+ stream_.doByteSwap[mode] = false;
+
+ // Get the buffer size. The buffer size and number of buffers
+ // (periods) is set when the jack server is started.
+ stream_.bufferSize = (int) jack_get_buffer_size( client );
+ *bufferSize = stream_.bufferSize;
+
+ stream_.nDeviceChannels[mode] = channels;
+ stream_.nUserChannels[mode] = channels;
+
+ // Set flags for buffer conversion.
+ stream_.doConvertBuffer[mode] = false;
+ if ( stream_.userFormat != stream_.deviceFormat[mode] )
+ stream_.doConvertBuffer[mode] = true;
+ if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] &&
+ stream_.nUserChannels[mode] > 1 )
+ stream_.doConvertBuffer[mode] = true;
+
+ // Allocate our JackHandle structure for the stream.
+ if ( handle == 0 ) {
+ try {
+ handle = new JackHandle;
+ }
+ catch ( std::bad_alloc& ) {
+ errorText_ = "RtApiJack::probeDeviceOpen: error allocating JackHandle memory.";
+ goto error;
+ }
+
+ if ( pthread_cond_init(&handle->condition, NULL) ) {
+ errorText_ = "RtApiJack::probeDeviceOpen: error initializing pthread condition variable.";
+ goto error;
+ }
+ stream_.apiHandle = (void *) handle;
+ handle->client = client;
+ }
+ handle->deviceName[mode] = deviceName;
+
+ // Allocate necessary internal buffers.
+ unsigned long bufferBytes;
+ bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
+ stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
+ if ( stream_.userBuffer[mode] == NULL ) {
+ errorText_ = "RtApiJack::probeDeviceOpen: error allocating user buffer memory.";
+ goto error;
+ }
+
+ if ( stream_.doConvertBuffer[mode] ) {
+
+ bool makeBuffer = true;
+ if ( mode == OUTPUT )
+ bufferBytes = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
+ else { // mode == INPUT
+ bufferBytes = stream_.nDeviceChannels[1] * formatBytes( stream_.deviceFormat[1] );
+ if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) {
+ unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes(stream_.deviceFormat[0]);
+ if ( bufferBytes < bytesOut ) makeBuffer = false;
+ }
+ }
+
+ if ( makeBuffer ) {
+ bufferBytes *= *bufferSize;
+ if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
+ stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
+ if ( stream_.deviceBuffer == NULL ) {
+ errorText_ = "RtApiJack::probeDeviceOpen: error allocating device buffer memory.";
+ goto error;
+ }
+ }
+ }
+
+ // Allocate memory for the Jack ports (channels) identifiers.
+ handle->ports[mode] = (jack_port_t **) malloc ( sizeof (jack_port_t *) * channels );
+ if ( handle->ports[mode] == NULL ) {
+ errorText_ = "RtApiJack::probeDeviceOpen: error allocating port memory.";
+ goto error;
+ }
+
+ stream_.device[mode] = device;
+ stream_.channelOffset[mode] = firstChannel;
+ stream_.state = STREAM_STOPPED;
+ stream_.callbackInfo.object = (void *) this;
+
+ if ( stream_.mode == OUTPUT && mode == INPUT )
+ // We had already set up the stream for output.
+ stream_.mode = DUPLEX;
+ else {
+ stream_.mode = mode;
+ jack_set_process_callback( handle->client, jackCallbackHandler, (void *) &stream_.callbackInfo );
+ jack_set_xrun_callback( handle->client, jackXrun, (void *) &stream_.apiHandle );
+ jack_on_shutdown( handle->client, jackShutdown, (void *) &stream_.callbackInfo );
+ }
+
+ // Register our ports.
+ char label[64];
+ if ( mode == OUTPUT ) {
+ for ( unsigned int i=0; i<stream_.nUserChannels[0]; i++ ) {
+ snprintf( label, 64, "outport %d", i );
+ handle->ports[0][i] = jack_port_register( handle->client, (const char *)label,
+ JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0 );
+ }
+ }
+ else {
+ for ( unsigned int i=0; i<stream_.nUserChannels[1]; i++ ) {
+ snprintf( label, 64, "inport %d", i );
+ handle->ports[1][i] = jack_port_register( handle->client, (const char *)label,
+ JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0 );
+ }
+ }
+
+ // Setup the buffer conversion information structure. We don't use
+ // buffers to do channel offsets, so we override that parameter
+ // here.
+ if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, 0 );
+
+ if ( options && options->flags & RTAUDIO_JACK_DONT_CONNECT ) shouldAutoconnect_ = false;
+
+ return SUCCESS;
+
+ error:
+ if ( handle ) {
+ pthread_cond_destroy( &handle->condition );
+ jack_client_close( handle->client );
+
+ if ( handle->ports[0] ) free( handle->ports[0] );
+ if ( handle->ports[1] ) free( handle->ports[1] );
+
+ delete handle;
+ stream_.apiHandle = 0;
+ }
+
+ for ( int i=0; i<2; i++ ) {
+ if ( stream_.userBuffer[i] ) {
+ free( stream_.userBuffer[i] );
+ stream_.userBuffer[i] = 0;
+ }
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+
+ return FAILURE;
+}
+
+void RtApiJack :: closeStream( void )
+{
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiJack::closeStream(): no open stream to close!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ JackHandle *handle = (JackHandle *) stream_.apiHandle;
+ if ( handle ) {
+
+ if ( stream_.state == STREAM_RUNNING )
+ jack_deactivate( handle->client );
+
+ jack_client_close( handle->client );
+ }
+
+ if ( handle ) {
+ if ( handle->ports[0] ) free( handle->ports[0] );
+ if ( handle->ports[1] ) free( handle->ports[1] );
+ pthread_cond_destroy( &handle->condition );
+ delete handle;
+ stream_.apiHandle = 0;
+ }
+
+ for ( int i=0; i<2; i++ ) {
+ if ( stream_.userBuffer[i] ) {
+ free( stream_.userBuffer[i] );
+ stream_.userBuffer[i] = 0;
+ }
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+
+ stream_.mode = UNINITIALIZED;
+ stream_.state = STREAM_CLOSED;
+}
+
+void RtApiJack :: startStream( void )
+{
+ verifyStream();
+ if ( stream_.state == STREAM_RUNNING ) {
+ errorText_ = "RtApiJack::startStream(): the stream is already running!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ #if defined( HAVE_GETTIMEOFDAY )
+ gettimeofday( &stream_.lastTickTimestamp, NULL );
+ #endif
+
+ JackHandle *handle = (JackHandle *) stream_.apiHandle;
+ int result = jack_activate( handle->client );
+ if ( result ) {
+ errorText_ = "RtApiJack::startStream(): unable to activate JACK client!";
+ goto unlock;
+ }
+
+ const char **ports;
+
+ // Get the list of available ports.
+ if ( shouldAutoconnect_ && (stream_.mode == OUTPUT || stream_.mode == DUPLEX) ) {
+ result = 1;
+ ports = jack_get_ports( handle->client, handle->deviceName[0].c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput);
+ if ( ports == NULL) {
+ errorText_ = "RtApiJack::startStream(): error determining available JACK input ports!";
+ goto unlock;
+ }
+
+ // Now make the port connections. Since RtAudio wasn't designed to
+ // allow the user to select particular channels of a device, we'll
+ // just open the first "nChannels" ports with offset.
+ for ( unsigned int i=0; i<stream_.nUserChannels[0]; i++ ) {
+ result = 1;
+ if ( ports[ stream_.channelOffset[0] + i ] )
+ result = jack_connect( handle->client, jack_port_name( handle->ports[0][i] ), ports[ stream_.channelOffset[0] + i ] );
+ if ( result ) {
+ free( ports );
+ errorText_ = "RtApiJack::startStream(): error connecting output ports!";
+ goto unlock;
+ }
+ }
+ free(ports);
+ }
+
+ if ( shouldAutoconnect_ && (stream_.mode == INPUT || stream_.mode == DUPLEX) ) {
+ result = 1;
+ ports = jack_get_ports( handle->client, handle->deviceName[1].c_str(), JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput );
+ if ( ports == NULL) {
+ errorText_ = "RtApiJack::startStream(): error determining available JACK output ports!";
+ goto unlock;
+ }
+
+ // Now make the port connections. See note above.
+ for ( unsigned int i=0; i<stream_.nUserChannels[1]; i++ ) {
+ result = 1;
+ if ( ports[ stream_.channelOffset[1] + i ] )
+ result = jack_connect( handle->client, ports[ stream_.channelOffset[1] + i ], jack_port_name( handle->ports[1][i] ) );
+ if ( result ) {
+ free( ports );
+ errorText_ = "RtApiJack::startStream(): error connecting input ports!";
+ goto unlock;
+ }
+ }
+ free(ports);
+ }
+
+ handle->drainCounter = 0;
+ handle->internalDrain = false;
+ stream_.state = STREAM_RUNNING;
+
+ unlock:
+ if ( result == 0 ) return;
+ error( RtAudioError::SYSTEM_ERROR );
+}
+
+void RtApiJack :: stopStream( void )
+{
+ verifyStream();
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiJack::stopStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ JackHandle *handle = (JackHandle *) stream_.apiHandle;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+
+ if ( handle->drainCounter == 0 ) {
+ handle->drainCounter = 2;
+ pthread_cond_wait( &handle->condition, &stream_.mutex ); // block until signaled
+ }
+ }
+
+ jack_deactivate( handle->client );
+ stream_.state = STREAM_STOPPED;
+}
+
+void RtApiJack :: abortStream( void )
+{
+ verifyStream();
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiJack::abortStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ JackHandle *handle = (JackHandle *) stream_.apiHandle;
+ handle->drainCounter = 2;
+
+ stopStream();
+}
+
+// This function will be called by a spawned thread when the user
+// callback function signals that the stream should be stopped or
+// aborted. It is necessary to handle it this way because the
+// callbackEvent() function must return before the jack_deactivate()
+// function will return.
+static void *jackStopStream( void *ptr )
+{
+ CallbackInfo *info = (CallbackInfo *) ptr;
+ RtApiJack *object = (RtApiJack *) info->object;
+
+ object->stopStream();
+ pthread_exit( NULL );
+}
+
+bool RtApiJack :: callbackEvent( unsigned long nframes )
+{
+ if ( stream_.state == STREAM_STOPPED || stream_.state == STREAM_STOPPING ) return SUCCESS;
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiCore::callbackEvent(): the stream is closed ... this shouldn't happen!";
+ error( RtAudioError::WARNING );
+ return FAILURE;
+ }
+ if ( stream_.bufferSize != nframes ) {
+ errorText_ = "RtApiCore::callbackEvent(): the JACK buffer size has changed ... cannot process!";
+ error( RtAudioError::WARNING );
+ return FAILURE;
+ }
+
+ CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo;
+ JackHandle *handle = (JackHandle *) stream_.apiHandle;
+
+ // Check if we were draining the stream and signal is finished.
+ if ( handle->drainCounter > 3 ) {
+ ThreadHandle threadId;
+
+ stream_.state = STREAM_STOPPING;
+ if ( handle->internalDrain == true )
+ pthread_create( &threadId, NULL, jackStopStream, info );
+ else
+ pthread_cond_signal( &handle->condition );
+ return SUCCESS;
+ }
+
+ // Invoke user callback first, to get fresh output data.
+ if ( handle->drainCounter == 0 ) {
+ RtAudioCallback callback = (RtAudioCallback) info->callback;
+ double streamTime = getStreamTime();
+ RtAudioStreamStatus status = 0;
+ if ( stream_.mode != INPUT && handle->xrun[0] == true ) {
+ status |= RTAUDIO_OUTPUT_UNDERFLOW;
+ handle->xrun[0] = false;
+ }
+ if ( stream_.mode != OUTPUT && handle->xrun[1] == true ) {
+ status |= RTAUDIO_INPUT_OVERFLOW;
+ handle->xrun[1] = false;
+ }
+ int cbReturnValue = callback( stream_.userBuffer[0], stream_.userBuffer[1],
+ stream_.bufferSize, streamTime, status, info->userData );
+ if ( cbReturnValue == 2 ) {
+ stream_.state = STREAM_STOPPING;
+ handle->drainCounter = 2;
+ ThreadHandle id;
+ pthread_create( &id, NULL, jackStopStream, info );
+ return SUCCESS;
+ }
+ else if ( cbReturnValue == 1 ) {
+ handle->drainCounter = 1;
+ handle->internalDrain = true;
+ }
+ }
+
+ jack_default_audio_sample_t *jackbuffer;
+ unsigned long bufferBytes = nframes * sizeof( jack_default_audio_sample_t );
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+
+ if ( handle->drainCounter > 1 ) { // write zeros to the output stream
+
+ for ( unsigned int i=0; i<stream_.nDeviceChannels[0]; i++ ) {
+ jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer( handle->ports[0][i], (jack_nframes_t) nframes );
+ memset( jackbuffer, 0, bufferBytes );
+ }
+
+ }
+ else if ( stream_.doConvertBuffer[0] ) {
+
+ convertBuffer( stream_.deviceBuffer, stream_.userBuffer[0], stream_.convertInfo[0] );
+
+ for ( unsigned int i=0; i<stream_.nDeviceChannels[0]; i++ ) {
+ jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer( handle->ports[0][i], (jack_nframes_t) nframes );
+ memcpy( jackbuffer, &stream_.deviceBuffer[i*bufferBytes], bufferBytes );
+ }
+ }
+ else { // no buffer conversion
+ for ( unsigned int i=0; i<stream_.nUserChannels[0]; i++ ) {
+ jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer( handle->ports[0][i], (jack_nframes_t) nframes );
+ memcpy( jackbuffer, &stream_.userBuffer[0][i*bufferBytes], bufferBytes );
+ }
+ }
+ }
+
+ // Don't bother draining input
+ if ( handle->drainCounter ) {
+ handle->drainCounter++;
+ goto unlock;
+ }
+
+ if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
+
+ if ( stream_.doConvertBuffer[1] ) {
+ for ( unsigned int i=0; i<stream_.nDeviceChannels[1]; i++ ) {
+ jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer( handle->ports[1][i], (jack_nframes_t) nframes );
+ memcpy( &stream_.deviceBuffer[i*bufferBytes], jackbuffer, bufferBytes );
+ }
+ convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] );
+ }
+ else { // no buffer conversion
+ for ( unsigned int i=0; i<stream_.nUserChannels[1]; i++ ) {
+ jackbuffer = (jack_default_audio_sample_t *) jack_port_get_buffer( handle->ports[1][i], (jack_nframes_t) nframes );
+ memcpy( &stream_.userBuffer[1][i*bufferBytes], jackbuffer, bufferBytes );
+ }
+ }
+ }
+
+ unlock:
+ RtApi::tickStreamTime();
+ return SUCCESS;
+}
+ //******************** End of __UNIX_JACK__ *********************//
+#endif
+
+#if defined(__WINDOWS_ASIO__) // ASIO API on Windows
+
+// The ASIO API is designed around a callback scheme, so this
+// implementation is similar to that used for OS-X CoreAudio and Linux
+// Jack. The primary constraint with ASIO is that it only allows
+// access to a single driver at a time. Thus, it is not possible to
+// have more than one simultaneous RtAudio stream.
+//
+// This implementation also requires a number of external ASIO files
+// and a few global variables. The ASIO callback scheme does not
+// allow for the passing of user data, so we must create a global
+// pointer to our callbackInfo structure.
+//
+// On unix systems, we make use of a pthread condition variable.
+// Since there is no equivalent in Windows, I hacked something based
+// on information found in
+// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html.
+
+#include "asiosys.h"
+#include "asio.h"
+#include "iasiothiscallresolver.h"
+#include "asiodrivers.h"
+#include <cmath>
+
+static AsioDrivers drivers;
+static ASIOCallbacks asioCallbacks;
+static ASIODriverInfo driverInfo;
+static CallbackInfo *asioCallbackInfo;
+static bool asioXRun;
+
+struct AsioHandle {
+ int drainCounter; // Tracks callback counts when draining
+ bool internalDrain; // Indicates if stop is initiated from callback or not.
+ ASIOBufferInfo *bufferInfos;
+ HANDLE condition;
+
+ AsioHandle()
+ :drainCounter(0), internalDrain(false), bufferInfos(0) {}
+};
+
+// Function declarations (definitions at end of section)
+static const char* getAsioErrorString( ASIOError result );
+static void sampleRateChanged( ASIOSampleRate sRate );
+static long asioMessages( long selector, long value, void* message, double* opt );
+
+RtApiAsio :: RtApiAsio()
+{
+ // ASIO cannot run on a multi-threaded appartment. You can call
+ // CoInitialize beforehand, but it must be for appartment threading
+ // (in which case, CoInitilialize will return S_FALSE here).
+ coInitialized_ = false;
+ HRESULT hr = CoInitialize( NULL );
+ if ( FAILED(hr) ) {
+ errorText_ = "RtApiAsio::ASIO requires a single-threaded appartment. Call CoInitializeEx(0,COINIT_APARTMENTTHREADED)";
+ error( RtAudioError::WARNING );
+ }
+ coInitialized_ = true;
+
+ drivers.removeCurrentDriver();
+ driverInfo.asioVersion = 2;
+
+ // See note in DirectSound implementation about GetDesktopWindow().
+ driverInfo.sysRef = GetForegroundWindow();
+}
+
+RtApiAsio :: ~RtApiAsio()
+{
+ if ( stream_.state != STREAM_CLOSED ) closeStream();
+ if ( coInitialized_ ) CoUninitialize();
+}
+
+unsigned int RtApiAsio :: getDeviceCount( void )
+{
+ return (unsigned int) drivers.asioGetNumDev();
+}
+
+RtAudio::DeviceInfo RtApiAsio :: getDeviceInfo( unsigned int device )
+{
+ RtAudio::DeviceInfo info;
+ info.probed = false;
+
+ // Get device ID
+ unsigned int nDevices = getDeviceCount();
+ if ( nDevices == 0 ) {
+ errorText_ = "RtApiAsio::getDeviceInfo: no devices found!";
+ error( RtAudioError::INVALID_USE );
+ return info;
+ }
+
+ if ( device >= nDevices ) {
+ errorText_ = "RtApiAsio::getDeviceInfo: device ID is invalid!";
+ error( RtAudioError::INVALID_USE );
+ return info;
+ }
+
+ // If a stream is already open, we cannot probe other devices. Thus, use the saved results.
+ if ( stream_.state != STREAM_CLOSED ) {
+ if ( device >= devices_.size() ) {
+ errorText_ = "RtApiAsio::getDeviceInfo: device ID was not present before stream was opened.";
+ error( RtAudioError::WARNING );
+ return info;
+ }
+ return devices_[ device ];
+ }
+
+ char driverName[32];
+ ASIOError result = drivers.asioGetDriverName( (int) device, driverName, 32 );
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::getDeviceInfo: unable to get driver name (" << getAsioErrorString( result ) << ").";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ info.name = driverName;
+
+ if ( !drivers.loadDriver( driverName ) ) {
+ errorStream_ << "RtApiAsio::getDeviceInfo: unable to load driver (" << driverName << ").";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ result = ASIOInit( &driverInfo );
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::getDeviceInfo: error (" << getAsioErrorString( result ) << ") initializing driver (" << driverName << ").";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // Determine the device channel information.
+ long inputChannels, outputChannels;
+ result = ASIOGetChannels( &inputChannels, &outputChannels );
+ if ( result != ASE_OK ) {
+ drivers.removeCurrentDriver();
+ errorStream_ << "RtApiAsio::getDeviceInfo: error (" << getAsioErrorString( result ) << ") getting channel count (" << driverName << ").";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ info.outputChannels = outputChannels;
+ info.inputChannels = inputChannels;
+ if ( info.outputChannels > 0 && info.inputChannels > 0 )
+ info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels;
+
+ // Determine the supported sample rates.
+ info.sampleRates.clear();
+ for ( unsigned int i=0; i<MAX_SAMPLE_RATES; i++ ) {
+ result = ASIOCanSampleRate( (ASIOSampleRate) SAMPLE_RATES[i] );
+ if ( result == ASE_OK ) {
+ info.sampleRates.push_back( SAMPLE_RATES[i] );
+
+ if ( !info.preferredSampleRate || ( SAMPLE_RATES[i] <= 48000 && SAMPLE_RATES[i] > info.preferredSampleRate ) )
+ info.preferredSampleRate = SAMPLE_RATES[i];
+ }
+ }
+
+ // Determine supported data types ... just check first channel and assume rest are the same.
+ ASIOChannelInfo channelInfo;
+ channelInfo.channel = 0;
+ channelInfo.isInput = true;
+ if ( info.inputChannels <= 0 ) channelInfo.isInput = false;
+ result = ASIOGetChannelInfo( &channelInfo );
+ if ( result != ASE_OK ) {
+ drivers.removeCurrentDriver();
+ errorStream_ << "RtApiAsio::getDeviceInfo: error (" << getAsioErrorString( result ) << ") getting driver channel info (" << driverName << ").";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ info.nativeFormats = 0;
+ if ( channelInfo.type == ASIOSTInt16MSB || channelInfo.type == ASIOSTInt16LSB )
+ info.nativeFormats |= RTAUDIO_SINT16;
+ else if ( channelInfo.type == ASIOSTInt32MSB || channelInfo.type == ASIOSTInt32LSB )
+ info.nativeFormats |= RTAUDIO_SINT32;
+ else if ( channelInfo.type == ASIOSTFloat32MSB || channelInfo.type == ASIOSTFloat32LSB )
+ info.nativeFormats |= RTAUDIO_FLOAT32;
+ else if ( channelInfo.type == ASIOSTFloat64MSB || channelInfo.type == ASIOSTFloat64LSB )
+ info.nativeFormats |= RTAUDIO_FLOAT64;
+ else if ( channelInfo.type == ASIOSTInt24MSB || channelInfo.type == ASIOSTInt24LSB )
+ info.nativeFormats |= RTAUDIO_SINT24;
+
+ if ( info.outputChannels > 0 )
+ if ( getDefaultOutputDevice() == device ) info.isDefaultOutput = true;
+ if ( info.inputChannels > 0 )
+ if ( getDefaultInputDevice() == device ) info.isDefaultInput = true;
+
+ info.probed = true;
+ drivers.removeCurrentDriver();
+ return info;
+}
+
+static void bufferSwitch( long index, ASIOBool /*processNow*/ )
+{
+ RtApiAsio *object = (RtApiAsio *) asioCallbackInfo->object;
+ object->callbackEvent( index );
+}
+
+void RtApiAsio :: saveDeviceInfo( void )
+{
+ devices_.clear();
+
+ unsigned int nDevices = getDeviceCount();
+ devices_.resize( nDevices );
+ for ( unsigned int i=0; i<nDevices; i++ )
+ devices_[i] = getDeviceInfo( i );
+}
+
+bool RtApiAsio :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options )
+{////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ bool isDuplexInput = mode == INPUT && stream_.mode == OUTPUT;
+
+ // For ASIO, a duplex stream MUST use the same driver.
+ if ( isDuplexInput && stream_.device[0] != device ) {
+ errorText_ = "RtApiAsio::probeDeviceOpen: an ASIO duplex stream must use the same device for input and output!";
+ return FAILURE;
+ }
+
+ char driverName[32];
+ ASIOError result = drivers.asioGetDriverName( (int) device, driverName, 32 );
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: unable to get driver name (" << getAsioErrorString( result ) << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Only load the driver once for duplex stream.
+ if ( !isDuplexInput ) {
+ // The getDeviceInfo() function will not work when a stream is open
+ // because ASIO does not allow multiple devices to run at the same
+ // time. Thus, we'll probe the system before opening a stream and
+ // save the results for use by getDeviceInfo().
+ this->saveDeviceInfo();
+
+ if ( !drivers.loadDriver( driverName ) ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: unable to load driver (" << driverName << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ result = ASIOInit( &driverInfo );
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: error (" << getAsioErrorString( result ) << ") initializing driver (" << driverName << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ }
+
+ // keep them before any "goto error", they are used for error cleanup + goto device boundary checks
+ bool buffersAllocated = false;
+ AsioHandle *handle = (AsioHandle *) stream_.apiHandle;
+ unsigned int nChannels;
+
+
+ // Check the device channel count.
+ long inputChannels, outputChannels;
+ result = ASIOGetChannels( &inputChannels, &outputChannels );
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: error (" << getAsioErrorString( result ) << ") getting channel count (" << driverName << ").";
+ errorText_ = errorStream_.str();
+ goto error;
+ }
+
+ if ( ( mode == OUTPUT && (channels+firstChannel) > (unsigned int) outputChannels) ||
+ ( mode == INPUT && (channels+firstChannel) > (unsigned int) inputChannels) ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") does not support requested channel count (" << channels << ") + offset (" << firstChannel << ").";
+ errorText_ = errorStream_.str();
+ goto error;
+ }
+ stream_.nDeviceChannels[mode] = channels;
+ stream_.nUserChannels[mode] = channels;
+ stream_.channelOffset[mode] = firstChannel;
+
+ // Verify the sample rate is supported.
+ result = ASIOCanSampleRate( (ASIOSampleRate) sampleRate );
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") does not support requested sample rate (" << sampleRate << ").";
+ errorText_ = errorStream_.str();
+ goto error;
+ }
+
+ // Get the current sample rate
+ ASIOSampleRate currentRate;
+ result = ASIOGetSampleRate( ¤tRate );
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error getting sample rate.";
+ errorText_ = errorStream_.str();
+ goto error;
+ }
+
+ // Set the sample rate only if necessary
+ if ( currentRate != sampleRate ) {
+ result = ASIOSetSampleRate( (ASIOSampleRate) sampleRate );
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error setting sample rate (" << sampleRate << ").";
+ errorText_ = errorStream_.str();
+ goto error;
+ }
+ }
+
+ // Determine the driver data type.
+ ASIOChannelInfo channelInfo;
+ channelInfo.channel = 0;
+ if ( mode == OUTPUT ) channelInfo.isInput = false;
+ else channelInfo.isInput = true;
+ result = ASIOGetChannelInfo( &channelInfo );
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString( result ) << ") getting data format.";
+ errorText_ = errorStream_.str();
+ goto error;
+ }
+
+ // Assuming WINDOWS host is always little-endian.
+ stream_.doByteSwap[mode] = false;
+ stream_.userFormat = format;
+ stream_.deviceFormat[mode] = 0;
+ if ( channelInfo.type == ASIOSTInt16MSB || channelInfo.type == ASIOSTInt16LSB ) {
+ stream_.deviceFormat[mode] = RTAUDIO_SINT16;
+ if ( channelInfo.type == ASIOSTInt16MSB ) stream_.doByteSwap[mode] = true;
+ }
+ else if ( channelInfo.type == ASIOSTInt32MSB || channelInfo.type == ASIOSTInt32LSB ) {
+ stream_.deviceFormat[mode] = RTAUDIO_SINT32;
+ if ( channelInfo.type == ASIOSTInt32MSB ) stream_.doByteSwap[mode] = true;
+ }
+ else if ( channelInfo.type == ASIOSTFloat32MSB || channelInfo.type == ASIOSTFloat32LSB ) {
+ stream_.deviceFormat[mode] = RTAUDIO_FLOAT32;
+ if ( channelInfo.type == ASIOSTFloat32MSB ) stream_.doByteSwap[mode] = true;
+ }
+ else if ( channelInfo.type == ASIOSTFloat64MSB || channelInfo.type == ASIOSTFloat64LSB ) {
+ stream_.deviceFormat[mode] = RTAUDIO_FLOAT64;
+ if ( channelInfo.type == ASIOSTFloat64MSB ) stream_.doByteSwap[mode] = true;
+ }
+ else if ( channelInfo.type == ASIOSTInt24MSB || channelInfo.type == ASIOSTInt24LSB ) {
+ stream_.deviceFormat[mode] = RTAUDIO_SINT24;
+ if ( channelInfo.type == ASIOSTInt24MSB ) stream_.doByteSwap[mode] = true;
+ }
+
+ if ( stream_.deviceFormat[mode] == 0 ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") data format not supported by RtAudio.";
+ errorText_ = errorStream_.str();
+ goto error;
+ }
+
+ // Set the buffer size. For a duplex stream, this will end up
+ // setting the buffer size based on the input constraints, which
+ // should be ok.
+ long minSize, maxSize, preferSize, granularity;
+ result = ASIOGetBufferSize( &minSize, &maxSize, &preferSize, &granularity );
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString( result ) << ") getting buffer size.";
+ errorText_ = errorStream_.str();
+ goto error;
+ }
+
+ if ( isDuplexInput ) {
+ // When this is the duplex input (output was opened before), then we have to use the same
+ // buffersize as the output, because it might use the preferred buffer size, which most
+ // likely wasn't passed as input to this. The buffer sizes have to be identically anyway,
+ // So instead of throwing an error, make them equal. The caller uses the reference
+ // to the "bufferSize" param as usual to set up processing buffers.
+
+ *bufferSize = stream_.bufferSize;
+
+ } else {
+ if ( *bufferSize == 0 ) *bufferSize = preferSize;
+ else if ( *bufferSize < (unsigned int) minSize ) *bufferSize = (unsigned int) minSize;
+ else if ( *bufferSize > (unsigned int) maxSize ) *bufferSize = (unsigned int) maxSize;
+ else if ( granularity == -1 ) {
+ // Make sure bufferSize is a power of two.
+ int log2_of_min_size = 0;
+ int log2_of_max_size = 0;
+
+ for ( unsigned int i = 0; i < sizeof(long) * 8; i++ ) {
+ if ( minSize & ((long)1 << i) ) log2_of_min_size = i;
+ if ( maxSize & ((long)1 << i) ) log2_of_max_size = i;
+ }
+
+ long min_delta = std::abs( (long)*bufferSize - ((long)1 << log2_of_min_size) );
+ int min_delta_num = log2_of_min_size;
+
+ for (int i = log2_of_min_size + 1; i <= log2_of_max_size; i++) {
+ long current_delta = std::abs( (long)*bufferSize - ((long)1 << i) );
+ if (current_delta < min_delta) {
+ min_delta = current_delta;
+ min_delta_num = i;
+ }
+ }
+
+ *bufferSize = ( (unsigned int)1 << min_delta_num );
+ if ( *bufferSize < (unsigned int) minSize ) *bufferSize = (unsigned int) minSize;
+ else if ( *bufferSize > (unsigned int) maxSize ) *bufferSize = (unsigned int) maxSize;
+ }
+ else if ( granularity != 0 ) {
+ // Set to an even multiple of granularity, rounding up.
+ *bufferSize = (*bufferSize + granularity-1) / granularity * granularity;
+ }
+ }
+
+ /*
+ // we don't use it anymore, see above!
+ // Just left it here for the case...
+ if ( isDuplexInput && stream_.bufferSize != *bufferSize ) {
+ errorText_ = "RtApiAsio::probeDeviceOpen: input/output buffersize discrepancy!";
+ goto error;
+ }
+ */
+
+ stream_.bufferSize = *bufferSize;
+ stream_.nBuffers = 2;
+
+ if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false;
+ else stream_.userInterleaved = true;
+
+ // ASIO always uses non-interleaved buffers.
+ stream_.deviceInterleaved[mode] = false;
+
+ // Allocate, if necessary, our AsioHandle structure for the stream.
+ if ( handle == 0 ) {
+ try {
+ handle = new AsioHandle;
+ }
+ catch ( std::bad_alloc& ) {
+ errorText_ = "RtApiAsio::probeDeviceOpen: error allocating AsioHandle memory.";
+ goto error;
+ }
+ handle->bufferInfos = 0;
+
+ // Create a manual-reset event.
+ handle->condition = CreateEvent( NULL, // no security
+ TRUE, // manual-reset
+ FALSE, // non-signaled initially
+ NULL ); // unnamed
+ stream_.apiHandle = (void *) handle;
+ }
+
+ // Create the ASIO internal buffers. Since RtAudio sets up input
+ // and output separately, we'll have to dispose of previously
+ // created output buffers for a duplex stream.
+ if ( mode == INPUT && stream_.mode == OUTPUT ) {
+ ASIODisposeBuffers();
+ if ( handle->bufferInfos ) free( handle->bufferInfos );
+ }
+
+ // Allocate, initialize, and save the bufferInfos in our stream callbackInfo structure.
+ unsigned int i;
+ nChannels = stream_.nDeviceChannels[0] + stream_.nDeviceChannels[1];
+ handle->bufferInfos = (ASIOBufferInfo *) malloc( nChannels * sizeof(ASIOBufferInfo) );
+ if ( handle->bufferInfos == NULL ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: error allocating bufferInfo memory for driver (" << driverName << ").";
+ errorText_ = errorStream_.str();
+ goto error;
+ }
+
+ ASIOBufferInfo *infos;
+ infos = handle->bufferInfos;
+ for ( i=0; i<stream_.nDeviceChannels[0]; i++, infos++ ) {
+ infos->isInput = ASIOFalse;
+ infos->channelNum = i + stream_.channelOffset[0];
+ infos->buffers[0] = infos->buffers[1] = 0;
+ }
+ for ( i=0; i<stream_.nDeviceChannels[1]; i++, infos++ ) {
+ infos->isInput = ASIOTrue;
+ infos->channelNum = i + stream_.channelOffset[1];
+ infos->buffers[0] = infos->buffers[1] = 0;
+ }
+
+ // prepare for callbacks
+ stream_.sampleRate = sampleRate;
+ stream_.device[mode] = device;
+ stream_.mode = isDuplexInput ? DUPLEX : mode;
+
+ // store this class instance before registering callbacks, that are going to use it
+ asioCallbackInfo = &stream_.callbackInfo;
+ stream_.callbackInfo.object = (void *) this;
+
+ // Set up the ASIO callback structure and create the ASIO data buffers.
+ asioCallbacks.bufferSwitch = &bufferSwitch;
+ asioCallbacks.sampleRateDidChange = &sampleRateChanged;
+ asioCallbacks.asioMessage = &asioMessages;
+ asioCallbacks.bufferSwitchTimeInfo = NULL;
+ result = ASIOCreateBuffers( handle->bufferInfos, nChannels, stream_.bufferSize, &asioCallbacks );
+ if ( result != ASE_OK ) {
+ // Standard method failed. This can happen with strict/misbehaving drivers that return valid buffer size ranges
+ // but only accept the preferred buffer size as parameter for ASIOCreateBuffers (e.g. Creative's ASIO driver).
+ // In that case, let's be naïve and try that instead.
+ *bufferSize = preferSize;
+ stream_.bufferSize = *bufferSize;
+ result = ASIOCreateBuffers( handle->bufferInfos, nChannels, stream_.bufferSize, &asioCallbacks );
+ }
+
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString( result ) << ") creating buffers.";
+ errorText_ = errorStream_.str();
+ goto error;
+ }
+ buffersAllocated = true;
+ stream_.state = STREAM_STOPPED;
+
+ // Set flags for buffer conversion.
+ stream_.doConvertBuffer[mode] = false;
+ if ( stream_.userFormat != stream_.deviceFormat[mode] )
+ stream_.doConvertBuffer[mode] = true;
+ if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] &&
+ stream_.nUserChannels[mode] > 1 )
+ stream_.doConvertBuffer[mode] = true;
+
+ // Allocate necessary internal buffers
+ unsigned long bufferBytes;
+ bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
+ stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
+ if ( stream_.userBuffer[mode] == NULL ) {
+ errorText_ = "RtApiAsio::probeDeviceOpen: error allocating user buffer memory.";
+ goto error;
+ }
+
+ if ( stream_.doConvertBuffer[mode] ) {
+
+ bool makeBuffer = true;
+ bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] );
+ if ( isDuplexInput && stream_.deviceBuffer ) {
+ unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
+ if ( bufferBytes <= bytesOut ) makeBuffer = false;
+ }
+
+ if ( makeBuffer ) {
+ bufferBytes *= *bufferSize;
+ if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
+ stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
+ if ( stream_.deviceBuffer == NULL ) {
+ errorText_ = "RtApiAsio::probeDeviceOpen: error allocating device buffer memory.";
+ goto error;
+ }
+ }
+ }
+
+ // Determine device latencies
+ long inputLatency, outputLatency;
+ result = ASIOGetLatencies( &inputLatency, &outputLatency );
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::probeDeviceOpen: driver (" << driverName << ") error (" << getAsioErrorString( result ) << ") getting latency.";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING); // warn but don't fail
+ }
+ else {
+ stream_.latency[0] = outputLatency;
+ stream_.latency[1] = inputLatency;
+ }
+
+ // Setup the buffer conversion information structure. We don't use
+ // buffers to do channel offsets, so we override that parameter
+ // here.
+ if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, 0 );
+
+ return SUCCESS;
+
+ error:
+ if ( !isDuplexInput ) {
+ // the cleanup for error in the duplex input, is done by RtApi::openStream
+ // So we clean up for single channel only
+
+ if ( buffersAllocated )
+ ASIODisposeBuffers();
+
+ drivers.removeCurrentDriver();
+
+ if ( handle ) {
+ CloseHandle( handle->condition );
+ if ( handle->bufferInfos )
+ free( handle->bufferInfos );
+
+ delete handle;
+ stream_.apiHandle = 0;
+ }
+
+
+ if ( stream_.userBuffer[mode] ) {
+ free( stream_.userBuffer[mode] );
+ stream_.userBuffer[mode] = 0;
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+ }
+
+ return FAILURE;
+}////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void RtApiAsio :: closeStream()
+{
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiAsio::closeStream(): no open stream to close!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ if ( stream_.state == STREAM_RUNNING ) {
+ stream_.state = STREAM_STOPPED;
+ ASIOStop();
+ }
+ ASIODisposeBuffers();
+ drivers.removeCurrentDriver();
+
+ AsioHandle *handle = (AsioHandle *) stream_.apiHandle;
+ if ( handle ) {
+ CloseHandle( handle->condition );
+ if ( handle->bufferInfos )
+ free( handle->bufferInfos );
+ delete handle;
+ stream_.apiHandle = 0;
+ }
+
+ for ( int i=0; i<2; i++ ) {
+ if ( stream_.userBuffer[i] ) {
+ free( stream_.userBuffer[i] );
+ stream_.userBuffer[i] = 0;
+ }
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+
+ stream_.mode = UNINITIALIZED;
+ stream_.state = STREAM_CLOSED;
+}
+
+bool stopThreadCalled = false;
+
+void RtApiAsio :: startStream()
+{
+ verifyStream();
+ if ( stream_.state == STREAM_RUNNING ) {
+ errorText_ = "RtApiAsio::startStream(): the stream is already running!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ #if defined( HAVE_GETTIMEOFDAY )
+ gettimeofday( &stream_.lastTickTimestamp, NULL );
+ #endif
+
+ AsioHandle *handle = (AsioHandle *) stream_.apiHandle;
+ ASIOError result = ASIOStart();
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::startStream: error (" << getAsioErrorString( result ) << ") starting device.";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+
+ handle->drainCounter = 0;
+ handle->internalDrain = false;
+ ResetEvent( handle->condition );
+ stream_.state = STREAM_RUNNING;
+ asioXRun = false;
+
+ unlock:
+ stopThreadCalled = false;
+
+ if ( result == ASE_OK ) return;
+ error( RtAudioError::SYSTEM_ERROR );
+}
+
+void RtApiAsio :: stopStream()
+{
+ verifyStream();
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiAsio::stopStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ AsioHandle *handle = (AsioHandle *) stream_.apiHandle;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+ if ( handle->drainCounter == 0 ) {
+ handle->drainCounter = 2;
+ WaitForSingleObject( handle->condition, INFINITE ); // block until signaled
+ }
+ }
+
+ stream_.state = STREAM_STOPPED;
+
+ ASIOError result = ASIOStop();
+ if ( result != ASE_OK ) {
+ errorStream_ << "RtApiAsio::stopStream: error (" << getAsioErrorString( result ) << ") stopping device.";
+ errorText_ = errorStream_.str();
+ }
+
+ if ( result == ASE_OK ) return;
+ error( RtAudioError::SYSTEM_ERROR );
+}
+
+void RtApiAsio :: abortStream()
+{
+ verifyStream();
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiAsio::abortStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ // The following lines were commented-out because some behavior was
+ // noted where the device buffers need to be zeroed to avoid
+ // continuing sound, even when the device buffers are completely
+ // disposed. So now, calling abort is the same as calling stop.
+ // AsioHandle *handle = (AsioHandle *) stream_.apiHandle;
+ // handle->drainCounter = 2;
+ stopStream();
+}
+
+// This function will be called by a spawned thread when the user
+// callback function signals that the stream should be stopped or
+// aborted. It is necessary to handle it this way because the
+// callbackEvent() function must return before the ASIOStop()
+// function will return.
+static unsigned __stdcall asioStopStream( void *ptr )
+{
+ CallbackInfo *info = (CallbackInfo *) ptr;
+ RtApiAsio *object = (RtApiAsio *) info->object;
+
+ object->stopStream();
+ _endthreadex( 0 );
+ return 0;
+}
+
+bool RtApiAsio :: callbackEvent( long bufferIndex )
+{
+ if ( stream_.state == STREAM_STOPPED || stream_.state == STREAM_STOPPING ) return SUCCESS;
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiAsio::callbackEvent(): the stream is closed ... this shouldn't happen!";
+ error( RtAudioError::WARNING );
+ return FAILURE;
+ }
+
+ CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo;
+ AsioHandle *handle = (AsioHandle *) stream_.apiHandle;
+
+ // Check if we were draining the stream and signal if finished.
+ if ( handle->drainCounter > 3 ) {
+
+ stream_.state = STREAM_STOPPING;
+ if ( handle->internalDrain == false )
+ SetEvent( handle->condition );
+ else { // spawn a thread to stop the stream
+ unsigned threadId;
+ stream_.callbackInfo.thread = _beginthreadex( NULL, 0, &asioStopStream,
+ &stream_.callbackInfo, 0, &threadId );
+ }
+ return SUCCESS;
+ }
+
+ // Invoke user callback to get fresh output data UNLESS we are
+ // draining stream.
+ if ( handle->drainCounter == 0 ) {
+ RtAudioCallback callback = (RtAudioCallback) info->callback;
+ double streamTime = getStreamTime();
+ RtAudioStreamStatus status = 0;
+ if ( stream_.mode != INPUT && asioXRun == true ) {
+ status |= RTAUDIO_OUTPUT_UNDERFLOW;
+ asioXRun = false;
+ }
+ if ( stream_.mode != OUTPUT && asioXRun == true ) {
+ status |= RTAUDIO_INPUT_OVERFLOW;
+ asioXRun = false;
+ }
+ int cbReturnValue = callback( stream_.userBuffer[0], stream_.userBuffer[1],
+ stream_.bufferSize, streamTime, status, info->userData );
+ if ( cbReturnValue == 2 ) {
+ stream_.state = STREAM_STOPPING;
+ handle->drainCounter = 2;
+ unsigned threadId;
+ stream_.callbackInfo.thread = _beginthreadex( NULL, 0, &asioStopStream,
+ &stream_.callbackInfo, 0, &threadId );
+ return SUCCESS;
+ }
+ else if ( cbReturnValue == 1 ) {
+ handle->drainCounter = 1;
+ handle->internalDrain = true;
+ }
+ }
+
+ unsigned int nChannels, bufferBytes, i, j;
+ nChannels = stream_.nDeviceChannels[0] + stream_.nDeviceChannels[1];
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+
+ bufferBytes = stream_.bufferSize * formatBytes( stream_.deviceFormat[0] );
+
+ if ( handle->drainCounter > 1 ) { // write zeros to the output stream
+
+ for ( i=0, j=0; i<nChannels; i++ ) {
+ if ( handle->bufferInfos[i].isInput != ASIOTrue )
+ memset( handle->bufferInfos[i].buffers[bufferIndex], 0, bufferBytes );
+ }
+
+ }
+ else if ( stream_.doConvertBuffer[0] ) {
+
+ convertBuffer( stream_.deviceBuffer, stream_.userBuffer[0], stream_.convertInfo[0] );
+ if ( stream_.doByteSwap[0] )
+ byteSwapBuffer( stream_.deviceBuffer,
+ stream_.bufferSize * stream_.nDeviceChannels[0],
+ stream_.deviceFormat[0] );
+
+ for ( i=0, j=0; i<nChannels; i++ ) {
+ if ( handle->bufferInfos[i].isInput != ASIOTrue )
+ memcpy( handle->bufferInfos[i].buffers[bufferIndex],
+ &stream_.deviceBuffer[j++*bufferBytes], bufferBytes );
+ }
+
+ }
+ else {
+
+ if ( stream_.doByteSwap[0] )
+ byteSwapBuffer( stream_.userBuffer[0],
+ stream_.bufferSize * stream_.nUserChannels[0],
+ stream_.userFormat );
+
+ for ( i=0, j=0; i<nChannels; i++ ) {
+ if ( handle->bufferInfos[i].isInput != ASIOTrue )
+ memcpy( handle->bufferInfos[i].buffers[bufferIndex],
+ &stream_.userBuffer[0][bufferBytes*j++], bufferBytes );
+ }
+
+ }
+ }
+
+ // Don't bother draining input
+ if ( handle->drainCounter ) {
+ handle->drainCounter++;
+ goto unlock;
+ }
+
+ if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
+
+ bufferBytes = stream_.bufferSize * formatBytes(stream_.deviceFormat[1]);
+
+ if (stream_.doConvertBuffer[1]) {
+
+ // Always interleave ASIO input data.
+ for ( i=0, j=0; i<nChannels; i++ ) {
+ if ( handle->bufferInfos[i].isInput == ASIOTrue )
+ memcpy( &stream_.deviceBuffer[j++*bufferBytes],
+ handle->bufferInfos[i].buffers[bufferIndex],
+ bufferBytes );
+ }
+
+ if ( stream_.doByteSwap[1] )
+ byteSwapBuffer( stream_.deviceBuffer,
+ stream_.bufferSize * stream_.nDeviceChannels[1],
+ stream_.deviceFormat[1] );
+ convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] );
+
+ }
+ else {
+ for ( i=0, j=0; i<nChannels; i++ ) {
+ if ( handle->bufferInfos[i].isInput == ASIOTrue ) {
+ memcpy( &stream_.userBuffer[1][bufferBytes*j++],
+ handle->bufferInfos[i].buffers[bufferIndex],
+ bufferBytes );
+ }
+ }
+
+ if ( stream_.doByteSwap[1] )
+ byteSwapBuffer( stream_.userBuffer[1],
+ stream_.bufferSize * stream_.nUserChannels[1],
+ stream_.userFormat );
+ }
+ }
+
+ unlock:
+ // The following call was suggested by Malte Clasen. While the API
+ // documentation indicates it should not be required, some device
+ // drivers apparently do not function correctly without it.
+ ASIOOutputReady();
+
+ RtApi::tickStreamTime();
+ return SUCCESS;
+}
+
+static void sampleRateChanged( ASIOSampleRate sRate )
+{
+ // The ASIO documentation says that this usually only happens during
+ // external sync. Audio processing is not stopped by the driver,
+ // actual sample rate might not have even changed, maybe only the
+ // sample rate status of an AES/EBU or S/PDIF digital input at the
+ // audio device.
+
+ RtApi *object = (RtApi *) asioCallbackInfo->object;
+ try {
+ object->stopStream();
+ }
+ catch ( RtAudioError &exception ) {
+ std::cerr << "\nRtApiAsio: sampleRateChanged() error (" << exception.getMessage() << ")!\n" << std::endl;
+ return;
+ }
+
+ std::cerr << "\nRtApiAsio: driver reports sample rate changed to " << sRate << " ... stream stopped!!!\n" << std::endl;
+}
+
+static long asioMessages( long selector, long value, void* /*message*/, double* /*opt*/ )
+{
+ long ret = 0;
+
+ switch( selector ) {
+ case kAsioSelectorSupported:
+ if ( value == kAsioResetRequest
+ || value == kAsioEngineVersion
+ || value == kAsioResyncRequest
+ || value == kAsioLatenciesChanged
+ // The following three were added for ASIO 2.0, you don't
+ // necessarily have to support them.
+ || value == kAsioSupportsTimeInfo
+ || value == kAsioSupportsTimeCode
+ || value == kAsioSupportsInputMonitor)
+ ret = 1L;
+ break;
+ case kAsioResetRequest:
+ // Defer the task and perform the reset of the driver during the
+ // next "safe" situation. You cannot reset the driver right now,
+ // as this code is called from the driver. Reset the driver is
+ // done by completely destruct is. I.e. ASIOStop(),
+ // ASIODisposeBuffers(), Destruction Afterwards you initialize the
+ // driver again.
+ std::cerr << "\nRtApiAsio: driver reset requested!!!" << std::endl;
+ ret = 1L;
+ break;
+ case kAsioResyncRequest:
+ // This informs the application that the driver encountered some
+ // non-fatal data loss. It is used for synchronization purposes
+ // of different media. Added mainly to work around the Win16Mutex
+ // problems in Windows 95/98 with the Windows Multimedia system,
+ // which could lose data because the Mutex was held too long by
+ // another thread. However a driver can issue it in other
+ // situations, too.
+ // std::cerr << "\nRtApiAsio: driver resync requested!!!" << std::endl;
+ asioXRun = true;
+ ret = 1L;
+ break;
+ case kAsioLatenciesChanged:
+ // This will inform the host application that the drivers were
+ // latencies changed. Beware, it this does not mean that the
+ // buffer sizes have changed! You might need to update internal
+ // delay data.
+ std::cerr << "\nRtApiAsio: driver latency may have changed!!!" << std::endl;
+ ret = 1L;
+ break;
+ case kAsioEngineVersion:
+ // Return the supported ASIO version of the host application. If
+ // a host application does not implement this selector, ASIO 1.0
+ // is assumed by the driver.
+ ret = 2L;
+ break;
+ case kAsioSupportsTimeInfo:
+ // Informs the driver whether the
+ // asioCallbacks.bufferSwitchTimeInfo() callback is supported.
+ // For compatibility with ASIO 1.0 drivers the host application
+ // should always support the "old" bufferSwitch method, too.
+ ret = 0;
+ break;
+ case kAsioSupportsTimeCode:
+ // Informs the driver whether application is interested in time
+ // code info. If an application does not need to know about time
+ // code, the driver has less work to do.
+ ret = 0;
+ break;
+ }
+ return ret;
+}
+
+static const char* getAsioErrorString( ASIOError result )
+{
+ struct Messages
+ {
+ ASIOError value;
+ const char*message;
+ };
+
+ static const Messages m[] =
+ {
+ { ASE_NotPresent, "Hardware input or output is not present or available." },
+ { ASE_HWMalfunction, "Hardware is malfunctioning." },
+ { ASE_InvalidParameter, "Invalid input parameter." },
+ { ASE_InvalidMode, "Invalid mode." },
+ { ASE_SPNotAdvancing, "Sample position not advancing." },
+ { ASE_NoClock, "Sample clock or rate cannot be determined or is not present." },
+ { ASE_NoMemory, "Not enough memory to complete the request." }
+ };
+
+ for ( unsigned int i = 0; i < sizeof(m)/sizeof(m[0]); ++i )
+ if ( m[i].value == result ) return m[i].message;
+
+ return "Unknown error.";
+}
+
+//******************** End of __WINDOWS_ASIO__ *********************//
+#endif
+
+
+#if defined(__WINDOWS_WASAPI__) // Windows WASAPI API
+
+// Authored by Marcus Tomlinson <themarcustomlinson@gmail.com>, April 2014
+// - Introduces support for the Windows WASAPI API
+// - Aims to deliver bit streams to and from hardware at the lowest possible latency, via the absolute minimum buffer sizes required
+// - Provides flexible stream configuration to an otherwise strict and inflexible WASAPI interface
+// - Includes automatic internal conversion of sample rate and buffer size between hardware and the user
+
+#ifndef INITGUID
+ #define INITGUID
+#endif
+
+#include <mfapi.h>
+#include <mferror.h>
+#include <mfplay.h>
+#include <mftransform.h>
+#include <wmcodecdsp.h>
+
+#include <audioclient.h>
+#include <avrt.h>
+#include <mmdeviceapi.h>
+#include <functiondiscoverykeys_devpkey.h>
+
+#ifndef MF_E_TRANSFORM_NEED_MORE_INPUT
+ #define MF_E_TRANSFORM_NEED_MORE_INPUT _HRESULT_TYPEDEF_(0xc00d6d72)
+#endif
+
+#ifndef MFSTARTUP_NOSOCKET
+ #define MFSTARTUP_NOSOCKET 0x1
+#endif
+
+#ifdef _MSC_VER
+ #pragma comment( lib, "ksuser" )
+ #pragma comment( lib, "mfplat.lib" )
+ #pragma comment( lib, "mfuuid.lib" )
+ #pragma comment( lib, "wmcodecdspuuid" )
+#endif
+
+//=============================================================================
+
+#define SAFE_RELEASE( objectPtr )\
+if ( objectPtr )\
+{\
+ objectPtr->Release();\
+ objectPtr = NULL;\
+}
+
+typedef HANDLE ( __stdcall *TAvSetMmThreadCharacteristicsPtr )( LPCWSTR TaskName, LPDWORD TaskIndex );
+
+//-----------------------------------------------------------------------------
+
+// WASAPI dictates stream sample rate, format, channel count, and in some cases, buffer size.
+// Therefore we must perform all necessary conversions to user buffers in order to satisfy these
+// requirements. WasapiBuffer ring buffers are used between HwIn->UserIn and UserOut->HwOut to
+// provide intermediate storage for read / write synchronization.
+class WasapiBuffer
+{
+public:
+ WasapiBuffer()
+ : buffer_( NULL ),
+ bufferSize_( 0 ),
+ inIndex_( 0 ),
+ outIndex_( 0 ) {}
+
+ ~WasapiBuffer() {
+ free( buffer_ );
+ }
+
+ // sets the length of the internal ring buffer
+ void setBufferSize( unsigned int bufferSize, unsigned int formatBytes ) {
+ free( buffer_ );
+
+ buffer_ = ( char* ) calloc( bufferSize, formatBytes );
+
+ bufferSize_ = bufferSize;
+ inIndex_ = 0;
+ outIndex_ = 0;
+ }
+
+ // attempt to push a buffer into the ring buffer at the current "in" index
+ bool pushBuffer( char* buffer, unsigned int bufferSize, RtAudioFormat format )
+ {
+ if ( !buffer || // incoming buffer is NULL
+ bufferSize == 0 || // incoming buffer has no data
+ bufferSize > bufferSize_ ) // incoming buffer too large
+ {
+ return false;
+ }
+
+ unsigned int relOutIndex = outIndex_;
+ unsigned int inIndexEnd = inIndex_ + bufferSize;
+ if ( relOutIndex < inIndex_ && inIndexEnd >= bufferSize_ ) {
+ relOutIndex += bufferSize_;
+ }
+
+ // the "IN" index CAN BEGIN at the "OUT" index
+ // the "IN" index CANNOT END at the "OUT" index
+ if ( inIndex_ < relOutIndex && inIndexEnd >= relOutIndex ) {
+ return false; // not enough space between "in" index and "out" index
+ }
+
+ // copy buffer from external to internal
+ int fromZeroSize = inIndex_ + bufferSize - bufferSize_;
+ fromZeroSize = fromZeroSize < 0 ? 0 : fromZeroSize;
+ int fromInSize = bufferSize - fromZeroSize;
+
+ switch( format )
+ {
+ case RTAUDIO_SINT8:
+ memcpy( &( ( char* ) buffer_ )[inIndex_], buffer, fromInSize * sizeof( char ) );
+ memcpy( buffer_, &( ( char* ) buffer )[fromInSize], fromZeroSize * sizeof( char ) );
+ break;
+ case RTAUDIO_SINT16:
+ memcpy( &( ( short* ) buffer_ )[inIndex_], buffer, fromInSize * sizeof( short ) );
+ memcpy( buffer_, &( ( short* ) buffer )[fromInSize], fromZeroSize * sizeof( short ) );
+ break;
+ case RTAUDIO_SINT24:
+ memcpy( &( ( S24* ) buffer_ )[inIndex_], buffer, fromInSize * sizeof( S24 ) );
+ memcpy( buffer_, &( ( S24* ) buffer )[fromInSize], fromZeroSize * sizeof( S24 ) );
+ break;
+ case RTAUDIO_SINT32:
+ memcpy( &( ( int* ) buffer_ )[inIndex_], buffer, fromInSize * sizeof( int ) );
+ memcpy( buffer_, &( ( int* ) buffer )[fromInSize], fromZeroSize * sizeof( int ) );
+ break;
+ case RTAUDIO_FLOAT32:
+ memcpy( &( ( float* ) buffer_ )[inIndex_], buffer, fromInSize * sizeof( float ) );
+ memcpy( buffer_, &( ( float* ) buffer )[fromInSize], fromZeroSize * sizeof( float ) );
+ break;
+ case RTAUDIO_FLOAT64:
+ memcpy( &( ( double* ) buffer_ )[inIndex_], buffer, fromInSize * sizeof( double ) );
+ memcpy( buffer_, &( ( double* ) buffer )[fromInSize], fromZeroSize * sizeof( double ) );
+ break;
+ }
+
+ // update "in" index
+ inIndex_ += bufferSize;
+ inIndex_ %= bufferSize_;
+
+ return true;
+ }
+
+ // attempt to pull a buffer from the ring buffer from the current "out" index
+ bool pullBuffer( char* buffer, unsigned int bufferSize, RtAudioFormat format )
+ {
+ if ( !buffer || // incoming buffer is NULL
+ bufferSize == 0 || // incoming buffer has no data
+ bufferSize > bufferSize_ ) // incoming buffer too large
+ {
+ return false;
+ }
+
+ unsigned int relInIndex = inIndex_;
+ unsigned int outIndexEnd = outIndex_ + bufferSize;
+ if ( relInIndex < outIndex_ && outIndexEnd >= bufferSize_ ) {
+ relInIndex += bufferSize_;
+ }
+
+ // the "OUT" index CANNOT BEGIN at the "IN" index
+ // the "OUT" index CAN END at the "IN" index
+ if ( outIndex_ <= relInIndex && outIndexEnd > relInIndex ) {
+ return false; // not enough space between "out" index and "in" index
+ }
+
+ // copy buffer from internal to external
+ int fromZeroSize = outIndex_ + bufferSize - bufferSize_;
+ fromZeroSize = fromZeroSize < 0 ? 0 : fromZeroSize;
+ int fromOutSize = bufferSize - fromZeroSize;
+
+ switch( format )
+ {
+ case RTAUDIO_SINT8:
+ memcpy( buffer, &( ( char* ) buffer_ )[outIndex_], fromOutSize * sizeof( char ) );
+ memcpy( &( ( char* ) buffer )[fromOutSize], buffer_, fromZeroSize * sizeof( char ) );
+ break;
+ case RTAUDIO_SINT16:
+ memcpy( buffer, &( ( short* ) buffer_ )[outIndex_], fromOutSize * sizeof( short ) );
+ memcpy( &( ( short* ) buffer )[fromOutSize], buffer_, fromZeroSize * sizeof( short ) );
+ break;
+ case RTAUDIO_SINT24:
+ memcpy( buffer, &( ( S24* ) buffer_ )[outIndex_], fromOutSize * sizeof( S24 ) );
+ memcpy( &( ( S24* ) buffer )[fromOutSize], buffer_, fromZeroSize * sizeof( S24 ) );
+ break;
+ case RTAUDIO_SINT32:
+ memcpy( buffer, &( ( int* ) buffer_ )[outIndex_], fromOutSize * sizeof( int ) );
+ memcpy( &( ( int* ) buffer )[fromOutSize], buffer_, fromZeroSize * sizeof( int ) );
+ break;
+ case RTAUDIO_FLOAT32:
+ memcpy( buffer, &( ( float* ) buffer_ )[outIndex_], fromOutSize * sizeof( float ) );
+ memcpy( &( ( float* ) buffer )[fromOutSize], buffer_, fromZeroSize * sizeof( float ) );
+ break;
+ case RTAUDIO_FLOAT64:
+ memcpy( buffer, &( ( double* ) buffer_ )[outIndex_], fromOutSize * sizeof( double ) );
+ memcpy( &( ( double* ) buffer )[fromOutSize], buffer_, fromZeroSize * sizeof( double ) );
+ break;
+ }
+
+ // update "out" index
+ outIndex_ += bufferSize;
+ outIndex_ %= bufferSize_;
+
+ return true;
+ }
+
+private:
+ char* buffer_;
+ unsigned int bufferSize_;
+ unsigned int inIndex_;
+ unsigned int outIndex_;
+};
+
+//-----------------------------------------------------------------------------
+
+// In order to satisfy WASAPI's buffer requirements, we need a means of converting sample rate
+// between HW and the user. The WasapiResampler class is used to perform this conversion between
+// HwIn->UserIn and UserOut->HwOut during the stream callback loop.
+class WasapiResampler
+{
+public:
+ WasapiResampler( bool isFloat, unsigned int bitsPerSample, unsigned int channelCount,
+ unsigned int inSampleRate, unsigned int outSampleRate )
+ : _bytesPerSample( bitsPerSample / 8 )
+ , _channelCount( channelCount )
+ , _sampleRatio( ( float ) outSampleRate / inSampleRate )
+ , _transformUnk( NULL )
+ , _transform( NULL )
+ , _mediaType( NULL )
+ , _inputMediaType( NULL )
+ , _outputMediaType( NULL )
+
+ #ifdef __IWMResamplerProps_FWD_DEFINED__
+ , _resamplerProps( NULL )
+ #endif
+ {
+ // 1. Initialization
+
+ MFStartup( MF_VERSION, MFSTARTUP_NOSOCKET );
+
+ // 2. Create Resampler Transform Object
+
+ CoCreateInstance( CLSID_CResamplerMediaObject, NULL, CLSCTX_INPROC_SERVER,
+ IID_IUnknown, ( void** ) &_transformUnk );
+
+ _transformUnk->QueryInterface( IID_PPV_ARGS( &_transform ) );
+
+ #ifdef __IWMResamplerProps_FWD_DEFINED__
+ _transformUnk->QueryInterface( IID_PPV_ARGS( &_resamplerProps ) );
+ _resamplerProps->SetHalfFilterLength( 60 ); // best conversion quality
+ #endif
+
+ // 3. Specify input / output format
+
+ MFCreateMediaType( &_mediaType );
+ _mediaType->SetGUID( MF_MT_MAJOR_TYPE, MFMediaType_Audio );
+ _mediaType->SetGUID( MF_MT_SUBTYPE, isFloat ? MFAudioFormat_Float : MFAudioFormat_PCM );
+ _mediaType->SetUINT32( MF_MT_AUDIO_NUM_CHANNELS, channelCount );
+ _mediaType->SetUINT32( MF_MT_AUDIO_SAMPLES_PER_SECOND, inSampleRate );
+ _mediaType->SetUINT32( MF_MT_AUDIO_BLOCK_ALIGNMENT, _bytesPerSample * channelCount );
+ _mediaType->SetUINT32( MF_MT_AUDIO_AVG_BYTES_PER_SECOND, _bytesPerSample * channelCount * inSampleRate );
+ _mediaType->SetUINT32( MF_MT_AUDIO_BITS_PER_SAMPLE, bitsPerSample );
+ _mediaType->SetUINT32( MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE );
+
+ MFCreateMediaType( &_inputMediaType );
+ _mediaType->CopyAllItems( _inputMediaType );
+
+ _transform->SetInputType( 0, _inputMediaType, 0 );
+
+ MFCreateMediaType( &_outputMediaType );
+ _mediaType->CopyAllItems( _outputMediaType );
+
+ _outputMediaType->SetUINT32( MF_MT_AUDIO_SAMPLES_PER_SECOND, outSampleRate );
+ _outputMediaType->SetUINT32( MF_MT_AUDIO_AVG_BYTES_PER_SECOND, _bytesPerSample * channelCount * outSampleRate );
+
+ _transform->SetOutputType( 0, _outputMediaType, 0 );
+
+ // 4. Send stream start messages to Resampler
+
+ _transform->ProcessMessage( MFT_MESSAGE_COMMAND_FLUSH, 0 );
+ _transform->ProcessMessage( MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0 );
+ _transform->ProcessMessage( MFT_MESSAGE_NOTIFY_START_OF_STREAM, 0 );
+ }
+
+ ~WasapiResampler()
+ {
+ // 8. Send stream stop messages to Resampler
+
+ _transform->ProcessMessage( MFT_MESSAGE_NOTIFY_END_OF_STREAM, 0 );
+ _transform->ProcessMessage( MFT_MESSAGE_NOTIFY_END_STREAMING, 0 );
+
+ // 9. Cleanup
+
+ MFShutdown();
+
+ SAFE_RELEASE( _transformUnk );
+ SAFE_RELEASE( _transform );
+ SAFE_RELEASE( _mediaType );
+ SAFE_RELEASE( _inputMediaType );
+ SAFE_RELEASE( _outputMediaType );
+
+ #ifdef __IWMResamplerProps_FWD_DEFINED__
+ SAFE_RELEASE( _resamplerProps );
+ #endif
+ }
+
+ void Convert( char* outBuffer, const char* inBuffer, unsigned int inSampleCount, unsigned int& outSampleCount )
+ {
+ unsigned int inputBufferSize = _bytesPerSample * _channelCount * inSampleCount;
+ if ( _sampleRatio == 1 )
+ {
+ // no sample rate conversion required
+ memcpy( outBuffer, inBuffer, inputBufferSize );
+ outSampleCount = inSampleCount;
+ return;
+ }
+
+ unsigned int outputBufferSize = ( unsigned int ) ceilf( inputBufferSize * _sampleRatio ) + ( _bytesPerSample * _channelCount );
+
+ IMFMediaBuffer* rInBuffer;
+ IMFSample* rInSample;
+ BYTE* rInByteBuffer = NULL;
+
+ // 5. Create Sample object from input data
+
+ MFCreateMemoryBuffer( inputBufferSize, &rInBuffer );
+
+ rInBuffer->Lock( &rInByteBuffer, NULL, NULL );
+ memcpy( rInByteBuffer, inBuffer, inputBufferSize );
+ rInBuffer->Unlock();
+ rInByteBuffer = NULL;
+
+ rInBuffer->SetCurrentLength( inputBufferSize );
+
+ MFCreateSample( &rInSample );
+ rInSample->AddBuffer( rInBuffer );
+
+ // 6. Pass input data to Resampler
+
+ _transform->ProcessInput( 0, rInSample, 0 );
+
+ SAFE_RELEASE( rInBuffer );
+ SAFE_RELEASE( rInSample );
+
+ // 7. Perform sample rate conversion
+
+ IMFMediaBuffer* rOutBuffer = NULL;
+ BYTE* rOutByteBuffer = NULL;
+
+ MFT_OUTPUT_DATA_BUFFER rOutDataBuffer;
+ DWORD rStatus;
+ DWORD rBytes = outputBufferSize; // maximum bytes accepted per ProcessOutput
+
+ // 7.1 Create Sample object for output data
+
+ memset( &rOutDataBuffer, 0, sizeof rOutDataBuffer );
+ MFCreateSample( &( rOutDataBuffer.pSample ) );
+ MFCreateMemoryBuffer( rBytes, &rOutBuffer );
+ rOutDataBuffer.pSample->AddBuffer( rOutBuffer );
+ rOutDataBuffer.dwStreamID = 0;
+ rOutDataBuffer.dwStatus = 0;
+ rOutDataBuffer.pEvents = NULL;
+
+ // 7.2 Get output data from Resampler
+
+ if ( _transform->ProcessOutput( 0, 1, &rOutDataBuffer, &rStatus ) == MF_E_TRANSFORM_NEED_MORE_INPUT )
+ {
+ outSampleCount = 0;
+ SAFE_RELEASE( rOutBuffer );
+ SAFE_RELEASE( rOutDataBuffer.pSample );
+ return;
+ }
+
+ // 7.3 Write output data to outBuffer
+
+ SAFE_RELEASE( rOutBuffer );
+ rOutDataBuffer.pSample->ConvertToContiguousBuffer( &rOutBuffer );
+ rOutBuffer->GetCurrentLength( &rBytes );
+
+ rOutBuffer->Lock( &rOutByteBuffer, NULL, NULL );
+ memcpy( outBuffer, rOutByteBuffer, rBytes );
+ rOutBuffer->Unlock();
+ rOutByteBuffer = NULL;
+
+ outSampleCount = rBytes / _bytesPerSample / _channelCount;
+ SAFE_RELEASE( rOutBuffer );
+ SAFE_RELEASE( rOutDataBuffer.pSample );
+ }
+
+private:
+ unsigned int _bytesPerSample;
+ unsigned int _channelCount;
+ float _sampleRatio;
+
+ IUnknown* _transformUnk;
+ IMFTransform* _transform;
+ IMFMediaType* _mediaType;
+ IMFMediaType* _inputMediaType;
+ IMFMediaType* _outputMediaType;
+
+ #ifdef __IWMResamplerProps_FWD_DEFINED__
+ IWMResamplerProps* _resamplerProps;
+ #endif
+};
+
+//-----------------------------------------------------------------------------
+
+// A structure to hold various information related to the WASAPI implementation.
+struct WasapiHandle
+{
+ IAudioClient* captureAudioClient;
+ IAudioClient* renderAudioClient;
+ IAudioCaptureClient* captureClient;
+ IAudioRenderClient* renderClient;
+ HANDLE captureEvent;
+ HANDLE renderEvent;
+
+ WasapiHandle()
+ : captureAudioClient( NULL ),
+ renderAudioClient( NULL ),
+ captureClient( NULL ),
+ renderClient( NULL ),
+ captureEvent( NULL ),
+ renderEvent( NULL ) {}
+};
+
+//=============================================================================
+
+RtApiWasapi::RtApiWasapi()
+ : coInitialized_( false ), deviceEnumerator_( NULL )
+{
+ // WASAPI can run either apartment or multi-threaded
+ HRESULT hr = CoInitialize( NULL );
+ if ( !FAILED( hr ) )
+ coInitialized_ = true;
+
+ // Instantiate device enumerator
+ hr = CoCreateInstance( __uuidof( MMDeviceEnumerator ), NULL,
+ CLSCTX_ALL, __uuidof( IMMDeviceEnumerator ),
+ ( void** ) &deviceEnumerator_ );
+
+ // If this runs on an old Windows, it will fail. Ignore and proceed.
+ if ( FAILED( hr ) )
+ deviceEnumerator_ = NULL;
+}
+
+//-----------------------------------------------------------------------------
+
+RtApiWasapi::~RtApiWasapi()
+{
+ if ( stream_.state != STREAM_CLOSED )
+ closeStream();
+
+ SAFE_RELEASE( deviceEnumerator_ );
+
+ // If this object previously called CoInitialize()
+ if ( coInitialized_ )
+ CoUninitialize();
+}
+
+//=============================================================================
+
+unsigned int RtApiWasapi::getDeviceCount( void )
+{
+ unsigned int captureDeviceCount = 0;
+ unsigned int renderDeviceCount = 0;
+
+ IMMDeviceCollection* captureDevices = NULL;
+ IMMDeviceCollection* renderDevices = NULL;
+
+ if ( !deviceEnumerator_ )
+ return 0;
+
+ // Count capture devices
+ errorText_.clear();
+ HRESULT hr = deviceEnumerator_->EnumAudioEndpoints( eCapture, DEVICE_STATE_ACTIVE, &captureDevices );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceCount: Unable to retrieve capture device collection.";
+ goto Exit;
+ }
+
+ hr = captureDevices->GetCount( &captureDeviceCount );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceCount: Unable to retrieve capture device count.";
+ goto Exit;
+ }
+
+ // Count render devices
+ hr = deviceEnumerator_->EnumAudioEndpoints( eRender, DEVICE_STATE_ACTIVE, &renderDevices );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceCount: Unable to retrieve render device collection.";
+ goto Exit;
+ }
+
+ hr = renderDevices->GetCount( &renderDeviceCount );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceCount: Unable to retrieve render device count.";
+ goto Exit;
+ }
+
+Exit:
+ // release all references
+ SAFE_RELEASE( captureDevices );
+ SAFE_RELEASE( renderDevices );
+
+ if ( errorText_.empty() )
+ return captureDeviceCount + renderDeviceCount;
+
+ error( RtAudioError::DRIVER_ERROR );
+ return 0;
+}
+
+//-----------------------------------------------------------------------------
+
+RtAudio::DeviceInfo RtApiWasapi::getDeviceInfo( unsigned int device )
+{
+ RtAudio::DeviceInfo info;
+ unsigned int captureDeviceCount = 0;
+ unsigned int renderDeviceCount = 0;
+ std::string defaultDeviceName;
+ bool isCaptureDevice = false;
+
+ PROPVARIANT deviceNameProp;
+ PROPVARIANT defaultDeviceNameProp;
+
+ IMMDeviceCollection* captureDevices = NULL;
+ IMMDeviceCollection* renderDevices = NULL;
+ IMMDevice* devicePtr = NULL;
+ IMMDevice* defaultDevicePtr = NULL;
+ IAudioClient* audioClient = NULL;
+ IPropertyStore* devicePropStore = NULL;
+ IPropertyStore* defaultDevicePropStore = NULL;
+
+ WAVEFORMATEX* deviceFormat = NULL;
+ WAVEFORMATEX* closestMatchFormat = NULL;
+
+ // probed
+ info.probed = false;
+
+ // Count capture devices
+ errorText_.clear();
+ RtAudioError::Type errorType = RtAudioError::DRIVER_ERROR;
+ HRESULT hr = deviceEnumerator_->EnumAudioEndpoints( eCapture, DEVICE_STATE_ACTIVE, &captureDevices );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve capture device collection.";
+ goto Exit;
+ }
+
+ hr = captureDevices->GetCount( &captureDeviceCount );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve capture device count.";
+ goto Exit;
+ }
+
+ // Count render devices
+ hr = deviceEnumerator_->EnumAudioEndpoints( eRender, DEVICE_STATE_ACTIVE, &renderDevices );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve render device collection.";
+ goto Exit;
+ }
+
+ hr = renderDevices->GetCount( &renderDeviceCount );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve render device count.";
+ goto Exit;
+ }
+
+ // validate device index
+ if ( device >= captureDeviceCount + renderDeviceCount ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Invalid device index.";
+ errorType = RtAudioError::INVALID_USE;
+ goto Exit;
+ }
+
+ // determine whether index falls within capture or render devices
+ if ( device >= renderDeviceCount ) {
+ hr = captureDevices->Item( device - renderDeviceCount, &devicePtr );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve capture device handle.";
+ goto Exit;
+ }
+ isCaptureDevice = true;
+ }
+ else {
+ hr = renderDevices->Item( device, &devicePtr );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve render device handle.";
+ goto Exit;
+ }
+ isCaptureDevice = false;
+ }
+
+ // get default device name
+ if ( isCaptureDevice ) {
+ hr = deviceEnumerator_->GetDefaultAudioEndpoint( eCapture, eConsole, &defaultDevicePtr );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve default capture device handle.";
+ goto Exit;
+ }
+ }
+ else {
+ hr = deviceEnumerator_->GetDefaultAudioEndpoint( eRender, eConsole, &defaultDevicePtr );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve default render device handle.";
+ goto Exit;
+ }
+ }
+
+ hr = defaultDevicePtr->OpenPropertyStore( STGM_READ, &defaultDevicePropStore );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to open default device property store.";
+ goto Exit;
+ }
+ PropVariantInit( &defaultDeviceNameProp );
+
+ hr = defaultDevicePropStore->GetValue( PKEY_Device_FriendlyName, &defaultDeviceNameProp );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve default device property: PKEY_Device_FriendlyName.";
+ goto Exit;
+ }
+
+ defaultDeviceName = convertCharPointerToStdString(defaultDeviceNameProp.pwszVal);
+
+ // name
+ hr = devicePtr->OpenPropertyStore( STGM_READ, &devicePropStore );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to open device property store.";
+ goto Exit;
+ }
+
+ PropVariantInit( &deviceNameProp );
+
+ hr = devicePropStore->GetValue( PKEY_Device_FriendlyName, &deviceNameProp );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve device property: PKEY_Device_FriendlyName.";
+ goto Exit;
+ }
+
+ info.name =convertCharPointerToStdString(deviceNameProp.pwszVal);
+
+ // is default
+ if ( isCaptureDevice ) {
+ info.isDefaultInput = info.name == defaultDeviceName;
+ info.isDefaultOutput = false;
+ }
+ else {
+ info.isDefaultInput = false;
+ info.isDefaultOutput = info.name == defaultDeviceName;
+ }
+
+ // channel count
+ hr = devicePtr->Activate( __uuidof( IAudioClient ), CLSCTX_ALL, NULL, ( void** ) &audioClient );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve device audio client.";
+ goto Exit;
+ }
+
+ hr = audioClient->GetMixFormat( &deviceFormat );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::getDeviceInfo: Unable to retrieve device mix format.";
+ goto Exit;
+ }
+
+ if ( isCaptureDevice ) {
+ info.inputChannels = deviceFormat->nChannels;
+ info.outputChannels = 0;
+ info.duplexChannels = 0;
+ }
+ else {
+ info.inputChannels = 0;
+ info.outputChannels = deviceFormat->nChannels;
+ info.duplexChannels = 0;
+ }
+
+ // sample rates
+ info.sampleRates.clear();
+
+ // allow support for all sample rates as we have a built-in sample rate converter
+ for ( unsigned int i = 0; i < MAX_SAMPLE_RATES; i++ ) {
+ info.sampleRates.push_back( SAMPLE_RATES[i] );
+ }
+ info.preferredSampleRate = deviceFormat->nSamplesPerSec;
+
+ // native format
+ info.nativeFormats = 0;
+
+ if ( deviceFormat->wFormatTag == WAVE_FORMAT_IEEE_FLOAT ||
+ ( deviceFormat->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
+ ( ( WAVEFORMATEXTENSIBLE* ) deviceFormat )->SubFormat == KSDATAFORMAT_SUBTYPE_IEEE_FLOAT ) )
+ {
+ if ( deviceFormat->wBitsPerSample == 32 ) {
+ info.nativeFormats |= RTAUDIO_FLOAT32;
+ }
+ else if ( deviceFormat->wBitsPerSample == 64 ) {
+ info.nativeFormats |= RTAUDIO_FLOAT64;
+ }
+ }
+ else if ( deviceFormat->wFormatTag == WAVE_FORMAT_PCM ||
+ ( deviceFormat->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
+ ( ( WAVEFORMATEXTENSIBLE* ) deviceFormat )->SubFormat == KSDATAFORMAT_SUBTYPE_PCM ) )
+ {
+ if ( deviceFormat->wBitsPerSample == 8 ) {
+ info.nativeFormats |= RTAUDIO_SINT8;
+ }
+ else if ( deviceFormat->wBitsPerSample == 16 ) {
+ info.nativeFormats |= RTAUDIO_SINT16;
+ }
+ else if ( deviceFormat->wBitsPerSample == 24 ) {
+ info.nativeFormats |= RTAUDIO_SINT24;
+ }
+ else if ( deviceFormat->wBitsPerSample == 32 ) {
+ info.nativeFormats |= RTAUDIO_SINT32;
+ }
+ }
+
+ // probed
+ info.probed = true;
+
+Exit:
+ // release all references
+ PropVariantClear( &deviceNameProp );
+ PropVariantClear( &defaultDeviceNameProp );
+
+ SAFE_RELEASE( captureDevices );
+ SAFE_RELEASE( renderDevices );
+ SAFE_RELEASE( devicePtr );
+ SAFE_RELEASE( defaultDevicePtr );
+ SAFE_RELEASE( audioClient );
+ SAFE_RELEASE( devicePropStore );
+ SAFE_RELEASE( defaultDevicePropStore );
+
+ CoTaskMemFree( deviceFormat );
+ CoTaskMemFree( closestMatchFormat );
+
+ if ( !errorText_.empty() )
+ error( errorType );
+ return info;
+}
+
+//-----------------------------------------------------------------------------
+
+unsigned int RtApiWasapi::getDefaultOutputDevice( void )
+{
+ for ( unsigned int i = 0; i < getDeviceCount(); i++ ) {
+ if ( getDeviceInfo( i ).isDefaultOutput ) {
+ return i;
+ }
+ }
+
+ return 0;
+}
+
+//-----------------------------------------------------------------------------
+
+unsigned int RtApiWasapi::getDefaultInputDevice( void )
+{
+ for ( unsigned int i = 0; i < getDeviceCount(); i++ ) {
+ if ( getDeviceInfo( i ).isDefaultInput ) {
+ return i;
+ }
+ }
+
+ return 0;
+}
+
+//-----------------------------------------------------------------------------
+
+void RtApiWasapi::closeStream( void )
+{
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiWasapi::closeStream: No open stream to close.";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ if ( stream_.state != STREAM_STOPPED )
+ stopStream();
+
+ // clean up stream memory
+ SAFE_RELEASE( ( ( WasapiHandle* ) stream_.apiHandle )->captureAudioClient )
+ SAFE_RELEASE( ( ( WasapiHandle* ) stream_.apiHandle )->renderAudioClient )
+
+ SAFE_RELEASE( ( ( WasapiHandle* ) stream_.apiHandle )->captureClient )
+ SAFE_RELEASE( ( ( WasapiHandle* ) stream_.apiHandle )->renderClient )
+
+ if ( ( ( WasapiHandle* ) stream_.apiHandle )->captureEvent )
+ CloseHandle( ( ( WasapiHandle* ) stream_.apiHandle )->captureEvent );
+
+ if ( ( ( WasapiHandle* ) stream_.apiHandle )->renderEvent )
+ CloseHandle( ( ( WasapiHandle* ) stream_.apiHandle )->renderEvent );
+
+ delete ( WasapiHandle* ) stream_.apiHandle;
+ stream_.apiHandle = NULL;
+
+ for ( int i = 0; i < 2; i++ ) {
+ if ( stream_.userBuffer[i] ) {
+ free( stream_.userBuffer[i] );
+ stream_.userBuffer[i] = 0;
+ }
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+
+ // update stream state
+ stream_.state = STREAM_CLOSED;
+}
+
+//-----------------------------------------------------------------------------
+
+void RtApiWasapi::startStream( void )
+{
+ verifyStream();
+
+ if ( stream_.state == STREAM_RUNNING ) {
+ errorText_ = "RtApiWasapi::startStream: The stream is already running.";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ #if defined( HAVE_GETTIMEOFDAY )
+ gettimeofday( &stream_.lastTickTimestamp, NULL );
+ #endif
+
+ // update stream state
+ stream_.state = STREAM_RUNNING;
+
+ // create WASAPI stream thread
+ stream_.callbackInfo.thread = ( ThreadHandle ) CreateThread( NULL, 0, runWasapiThread, this, CREATE_SUSPENDED, NULL );
+
+ if ( !stream_.callbackInfo.thread ) {
+ errorText_ = "RtApiWasapi::startStream: Unable to instantiate callback thread.";
+ error( RtAudioError::THREAD_ERROR );
+ }
+ else {
+ SetThreadPriority( ( void* ) stream_.callbackInfo.thread, stream_.callbackInfo.priority );
+ ResumeThread( ( void* ) stream_.callbackInfo.thread );
+ }
+}
+
+//-----------------------------------------------------------------------------
+
+void RtApiWasapi::stopStream( void )
+{
+ verifyStream();
+
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiWasapi::stopStream: The stream is already stopped.";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ // inform stream thread by setting stream state to STREAM_STOPPING
+ stream_.state = STREAM_STOPPING;
+
+ // wait until stream thread is stopped
+ while( stream_.state != STREAM_STOPPED ) {
+ Sleep( 1 );
+ }
+
+ // Wait for the last buffer to play before stopping.
+ Sleep( 1000 * stream_.bufferSize / stream_.sampleRate );
+
+ // close thread handle
+ if ( stream_.callbackInfo.thread && !CloseHandle( ( void* ) stream_.callbackInfo.thread ) ) {
+ errorText_ = "RtApiWasapi::stopStream: Unable to close callback thread.";
+ error( RtAudioError::THREAD_ERROR );
+ return;
+ }
+
+ stream_.callbackInfo.thread = (ThreadHandle) NULL;
+}
+
+//-----------------------------------------------------------------------------
+
+void RtApiWasapi::abortStream( void )
+{
+ verifyStream();
+
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiWasapi::abortStream: The stream is already stopped.";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ // inform stream thread by setting stream state to STREAM_STOPPING
+ stream_.state = STREAM_STOPPING;
+
+ // wait until stream thread is stopped
+ while ( stream_.state != STREAM_STOPPED ) {
+ Sleep( 1 );
+ }
+
+ // close thread handle
+ if ( stream_.callbackInfo.thread && !CloseHandle( ( void* ) stream_.callbackInfo.thread ) ) {
+ errorText_ = "RtApiWasapi::abortStream: Unable to close callback thread.";
+ error( RtAudioError::THREAD_ERROR );
+ return;
+ }
+
+ stream_.callbackInfo.thread = (ThreadHandle) NULL;
+}
+
+//-----------------------------------------------------------------------------
+
+bool RtApiWasapi::probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int* bufferSize,
+ RtAudio::StreamOptions* options )
+{
+ bool methodResult = FAILURE;
+ unsigned int captureDeviceCount = 0;
+ unsigned int renderDeviceCount = 0;
+
+ IMMDeviceCollection* captureDevices = NULL;
+ IMMDeviceCollection* renderDevices = NULL;
+ IMMDevice* devicePtr = NULL;
+ WAVEFORMATEX* deviceFormat = NULL;
+ unsigned int bufferBytes;
+ stream_.state = STREAM_STOPPED;
+
+ // create API Handle if not already created
+ if ( !stream_.apiHandle )
+ stream_.apiHandle = ( void* ) new WasapiHandle();
+
+ // Count capture devices
+ errorText_.clear();
+ RtAudioError::Type errorType = RtAudioError::DRIVER_ERROR;
+ HRESULT hr = deviceEnumerator_->EnumAudioEndpoints( eCapture, DEVICE_STATE_ACTIVE, &captureDevices );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve capture device collection.";
+ goto Exit;
+ }
+
+ hr = captureDevices->GetCount( &captureDeviceCount );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve capture device count.";
+ goto Exit;
+ }
+
+ // Count render devices
+ hr = deviceEnumerator_->EnumAudioEndpoints( eRender, DEVICE_STATE_ACTIVE, &renderDevices );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device collection.";
+ goto Exit;
+ }
+
+ hr = renderDevices->GetCount( &renderDeviceCount );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device count.";
+ goto Exit;
+ }
+
+ // validate device index
+ if ( device >= captureDeviceCount + renderDeviceCount ) {
+ errorType = RtAudioError::INVALID_USE;
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Invalid device index.";
+ goto Exit;
+ }
+
+ // if device index falls within capture devices
+ if ( device >= renderDeviceCount ) {
+ if ( mode != INPUT ) {
+ errorType = RtAudioError::INVALID_USE;
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Capture device selected as output device.";
+ goto Exit;
+ }
+
+ // retrieve captureAudioClient from devicePtr
+ IAudioClient*& captureAudioClient = ( ( WasapiHandle* ) stream_.apiHandle )->captureAudioClient;
+
+ hr = captureDevices->Item( device - renderDeviceCount, &devicePtr );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve capture device handle.";
+ goto Exit;
+ }
+
+ hr = devicePtr->Activate( __uuidof( IAudioClient ), CLSCTX_ALL,
+ NULL, ( void** ) &captureAudioClient );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve capture device audio client.";
+ goto Exit;
+ }
+
+ hr = captureAudioClient->GetMixFormat( &deviceFormat );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve capture device mix format.";
+ goto Exit;
+ }
+
+ stream_.nDeviceChannels[mode] = deviceFormat->nChannels;
+ captureAudioClient->GetStreamLatency( ( long long* ) &stream_.latency[mode] );
+ }
+
+ // if device index falls within render devices and is configured for loopback
+ if ( device < renderDeviceCount && mode == INPUT )
+ {
+ // if renderAudioClient is not initialised, initialise it now
+ IAudioClient*& renderAudioClient = ( ( WasapiHandle* ) stream_.apiHandle )->renderAudioClient;
+ if ( !renderAudioClient )
+ {
+ probeDeviceOpen( device, OUTPUT, channels, firstChannel, sampleRate, format, bufferSize, options );
+ }
+
+ // retrieve captureAudioClient from devicePtr
+ IAudioClient*& captureAudioClient = ( ( WasapiHandle* ) stream_.apiHandle )->captureAudioClient;
+
+ hr = renderDevices->Item( device, &devicePtr );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device handle.";
+ goto Exit;
+ }
+
+ hr = devicePtr->Activate( __uuidof( IAudioClient ), CLSCTX_ALL,
+ NULL, ( void** ) &captureAudioClient );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device audio client.";
+ goto Exit;
+ }
+
+ hr = captureAudioClient->GetMixFormat( &deviceFormat );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device mix format.";
+ goto Exit;
+ }
+
+ stream_.nDeviceChannels[mode] = deviceFormat->nChannels;
+ captureAudioClient->GetStreamLatency( ( long long* ) &stream_.latency[mode] );
+ }
+
+ // if device index falls within render devices and is configured for output
+ if ( device < renderDeviceCount && mode == OUTPUT )
+ {
+ // if renderAudioClient is already initialised, don't initialise it again
+ IAudioClient*& renderAudioClient = ( ( WasapiHandle* ) stream_.apiHandle )->renderAudioClient;
+ if ( renderAudioClient )
+ {
+ methodResult = SUCCESS;
+ goto Exit;
+ }
+
+ hr = renderDevices->Item( device, &devicePtr );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device handle.";
+ goto Exit;
+ }
+
+ hr = devicePtr->Activate( __uuidof( IAudioClient ), CLSCTX_ALL,
+ NULL, ( void** ) &renderAudioClient );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device audio client.";
+ goto Exit;
+ }
+
+ hr = renderAudioClient->GetMixFormat( &deviceFormat );
+ if ( FAILED( hr ) ) {
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Unable to retrieve render device mix format.";
+ goto Exit;
+ }
+
+ stream_.nDeviceChannels[mode] = deviceFormat->nChannels;
+ renderAudioClient->GetStreamLatency( ( long long* ) &stream_.latency[mode] );
+ }
+
+ // fill stream data
+ if ( ( stream_.mode == OUTPUT && mode == INPUT ) ||
+ ( stream_.mode == INPUT && mode == OUTPUT ) ) {
+ stream_.mode = DUPLEX;
+ }
+ else {
+ stream_.mode = mode;
+ }
+
+ stream_.device[mode] = device;
+ stream_.doByteSwap[mode] = false;
+ stream_.sampleRate = sampleRate;
+ stream_.bufferSize = *bufferSize;
+ stream_.nBuffers = 1;
+ stream_.nUserChannels[mode] = channels;
+ stream_.channelOffset[mode] = firstChannel;
+ stream_.userFormat = format;
+ stream_.deviceFormat[mode] = getDeviceInfo( device ).nativeFormats;
+
+ if ( options && options->flags & RTAUDIO_NONINTERLEAVED )
+ stream_.userInterleaved = false;
+ else
+ stream_.userInterleaved = true;
+ stream_.deviceInterleaved[mode] = true;
+
+ // Set flags for buffer conversion.
+ stream_.doConvertBuffer[mode] = false;
+ if ( stream_.userFormat != stream_.deviceFormat[mode] ||
+ stream_.nUserChannels[0] != stream_.nDeviceChannels[0] ||
+ stream_.nUserChannels[1] != stream_.nDeviceChannels[1] )
+ stream_.doConvertBuffer[mode] = true;
+ else if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] &&
+ stream_.nUserChannels[mode] > 1 )
+ stream_.doConvertBuffer[mode] = true;
+
+ if ( stream_.doConvertBuffer[mode] )
+ setConvertInfo( mode, 0 );
+
+ // Allocate necessary internal buffers
+ bufferBytes = stream_.nUserChannels[mode] * stream_.bufferSize * formatBytes( stream_.userFormat );
+
+ stream_.userBuffer[mode] = ( char* ) calloc( bufferBytes, 1 );
+ if ( !stream_.userBuffer[mode] ) {
+ errorType = RtAudioError::MEMORY_ERROR;
+ errorText_ = "RtApiWasapi::probeDeviceOpen: Error allocating user buffer memory.";
+ goto Exit;
+ }
+
+ if ( options && options->flags & RTAUDIO_SCHEDULE_REALTIME )
+ stream_.callbackInfo.priority = 15;
+ else
+ stream_.callbackInfo.priority = 0;
+
+ ///! TODO: RTAUDIO_MINIMIZE_LATENCY // Provide stream buffers directly to callback
+ ///! TODO: RTAUDIO_HOG_DEVICE // Exclusive mode
+
+ methodResult = SUCCESS;
+
+Exit:
+ //clean up
+ SAFE_RELEASE( captureDevices );
+ SAFE_RELEASE( renderDevices );
+ SAFE_RELEASE( devicePtr );
+ CoTaskMemFree( deviceFormat );
+
+ // if method failed, close the stream
+ if ( methodResult == FAILURE )
+ closeStream();
+
+ if ( !errorText_.empty() )
+ error( errorType );
+ return methodResult;
+}
+
+//=============================================================================
+
+DWORD WINAPI RtApiWasapi::runWasapiThread( void* wasapiPtr )
+{
+ if ( wasapiPtr )
+ ( ( RtApiWasapi* ) wasapiPtr )->wasapiThread();
+
+ return 0;
+}
+
+DWORD WINAPI RtApiWasapi::stopWasapiThread( void* wasapiPtr )
+{
+ if ( wasapiPtr )
+ ( ( RtApiWasapi* ) wasapiPtr )->stopStream();
+
+ return 0;
+}
+
+DWORD WINAPI RtApiWasapi::abortWasapiThread( void* wasapiPtr )
+{
+ if ( wasapiPtr )
+ ( ( RtApiWasapi* ) wasapiPtr )->abortStream();
+
+ return 0;
+}
+
+//-----------------------------------------------------------------------------
+
+void RtApiWasapi::wasapiThread()
+{
+ // as this is a new thread, we must CoInitialize it
+ CoInitialize( NULL );
+
+ HRESULT hr;
+
+ IAudioClient* captureAudioClient = ( ( WasapiHandle* ) stream_.apiHandle )->captureAudioClient;
+ IAudioClient* renderAudioClient = ( ( WasapiHandle* ) stream_.apiHandle )->renderAudioClient;
+ IAudioCaptureClient* captureClient = ( ( WasapiHandle* ) stream_.apiHandle )->captureClient;
+ IAudioRenderClient* renderClient = ( ( WasapiHandle* ) stream_.apiHandle )->renderClient;
+ HANDLE captureEvent = ( ( WasapiHandle* ) stream_.apiHandle )->captureEvent;
+ HANDLE renderEvent = ( ( WasapiHandle* ) stream_.apiHandle )->renderEvent;
+
+ WAVEFORMATEX* captureFormat = NULL;
+ WAVEFORMATEX* renderFormat = NULL;
+ float captureSrRatio = 0.0f;
+ float renderSrRatio = 0.0f;
+ WasapiBuffer captureBuffer;
+ WasapiBuffer renderBuffer;
+ WasapiResampler* captureResampler = NULL;
+ WasapiResampler* renderResampler = NULL;
+
+ // declare local stream variables
+ RtAudioCallback callback = ( RtAudioCallback ) stream_.callbackInfo.callback;
+ BYTE* streamBuffer = NULL;
+ unsigned long captureFlags = 0;
+ unsigned int bufferFrameCount = 0;
+ unsigned int numFramesPadding = 0;
+ unsigned int convBufferSize = 0;
+ bool loopbackEnabled = stream_.device[INPUT] == stream_.device[OUTPUT];
+ bool callbackPushed = true;
+ bool callbackPulled = false;
+ bool callbackStopped = false;
+ int callbackResult = 0;
+
+ // convBuffer is used to store converted buffers between WASAPI and the user
+ char* convBuffer = NULL;
+ unsigned int convBuffSize = 0;
+ unsigned int deviceBuffSize = 0;
+
+ std::string errorText;
+ RtAudioError::Type errorType = RtAudioError::DRIVER_ERROR;
+
+ // Attempt to assign "Pro Audio" characteristic to thread
+ HMODULE AvrtDll = LoadLibrary( (LPCTSTR) "AVRT.dll" );
+ if ( AvrtDll ) {
+ DWORD taskIndex = 0;
+ TAvSetMmThreadCharacteristicsPtr AvSetMmThreadCharacteristicsPtr =
+ ( TAvSetMmThreadCharacteristicsPtr ) (void(*)()) GetProcAddress( AvrtDll, "AvSetMmThreadCharacteristicsW" );
+ AvSetMmThreadCharacteristicsPtr( L"Pro Audio", &taskIndex );
+ FreeLibrary( AvrtDll );
+ }
+
+ // start capture stream if applicable
+ if ( captureAudioClient ) {
+ hr = captureAudioClient->GetMixFormat( &captureFormat );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to retrieve device mix format.";
+ goto Exit;
+ }
+
+ // init captureResampler
+ captureResampler = new WasapiResampler( stream_.deviceFormat[INPUT] == RTAUDIO_FLOAT32 || stream_.deviceFormat[INPUT] == RTAUDIO_FLOAT64,
+ formatBytes( stream_.deviceFormat[INPUT] ) * 8, stream_.nDeviceChannels[INPUT],
+ captureFormat->nSamplesPerSec, stream_.sampleRate );
+
+ captureSrRatio = ( ( float ) captureFormat->nSamplesPerSec / stream_.sampleRate );
+
+ if ( !captureClient ) {
+ hr = captureAudioClient->Initialize( AUDCLNT_SHAREMODE_SHARED,
+ loopbackEnabled ? AUDCLNT_STREAMFLAGS_LOOPBACK : AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
+ 0,
+ 0,
+ captureFormat,
+ NULL );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to initialize capture audio client.";
+ goto Exit;
+ }
+
+ hr = captureAudioClient->GetService( __uuidof( IAudioCaptureClient ),
+ ( void** ) &captureClient );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to retrieve capture client handle.";
+ goto Exit;
+ }
+
+ // don't configure captureEvent if in loopback mode
+ if ( !loopbackEnabled )
+ {
+ // configure captureEvent to trigger on every available capture buffer
+ captureEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
+ if ( !captureEvent ) {
+ errorType = RtAudioError::SYSTEM_ERROR;
+ errorText = "RtApiWasapi::wasapiThread: Unable to create capture event.";
+ goto Exit;
+ }
+
+ hr = captureAudioClient->SetEventHandle( captureEvent );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to set capture event handle.";
+ goto Exit;
+ }
+
+ ( ( WasapiHandle* ) stream_.apiHandle )->captureEvent = captureEvent;
+ }
+
+ ( ( WasapiHandle* ) stream_.apiHandle )->captureClient = captureClient;
+
+ // reset the capture stream
+ hr = captureAudioClient->Reset();
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to reset capture stream.";
+ goto Exit;
+ }
+
+ // start the capture stream
+ hr = captureAudioClient->Start();
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to start capture stream.";
+ goto Exit;
+ }
+ }
+
+ unsigned int inBufferSize = 0;
+ hr = captureAudioClient->GetBufferSize( &inBufferSize );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to get capture buffer size.";
+ goto Exit;
+ }
+
+ // scale outBufferSize according to stream->user sample rate ratio
+ unsigned int outBufferSize = ( unsigned int ) ceilf( stream_.bufferSize * captureSrRatio ) * stream_.nDeviceChannels[INPUT];
+ inBufferSize *= stream_.nDeviceChannels[INPUT];
+
+ // set captureBuffer size
+ captureBuffer.setBufferSize( inBufferSize + outBufferSize, formatBytes( stream_.deviceFormat[INPUT] ) );
+ }
+
+ // start render stream if applicable
+ if ( renderAudioClient ) {
+ hr = renderAudioClient->GetMixFormat( &renderFormat );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to retrieve device mix format.";
+ goto Exit;
+ }
+
+ // init renderResampler
+ renderResampler = new WasapiResampler( stream_.deviceFormat[OUTPUT] == RTAUDIO_FLOAT32 || stream_.deviceFormat[OUTPUT] == RTAUDIO_FLOAT64,
+ formatBytes( stream_.deviceFormat[OUTPUT] ) * 8, stream_.nDeviceChannels[OUTPUT],
+ stream_.sampleRate, renderFormat->nSamplesPerSec );
+
+ renderSrRatio = ( ( float ) renderFormat->nSamplesPerSec / stream_.sampleRate );
+
+ if ( !renderClient ) {
+ hr = renderAudioClient->Initialize( AUDCLNT_SHAREMODE_SHARED,
+ AUDCLNT_STREAMFLAGS_EVENTCALLBACK,
+ 0,
+ 0,
+ renderFormat,
+ NULL );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to initialize render audio client.";
+ goto Exit;
+ }
+
+ hr = renderAudioClient->GetService( __uuidof( IAudioRenderClient ),
+ ( void** ) &renderClient );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to retrieve render client handle.";
+ goto Exit;
+ }
+
+ // configure renderEvent to trigger on every available render buffer
+ renderEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
+ if ( !renderEvent ) {
+ errorType = RtAudioError::SYSTEM_ERROR;
+ errorText = "RtApiWasapi::wasapiThread: Unable to create render event.";
+ goto Exit;
+ }
+
+ hr = renderAudioClient->SetEventHandle( renderEvent );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to set render event handle.";
+ goto Exit;
+ }
+
+ ( ( WasapiHandle* ) stream_.apiHandle )->renderClient = renderClient;
+ ( ( WasapiHandle* ) stream_.apiHandle )->renderEvent = renderEvent;
+
+ // reset the render stream
+ hr = renderAudioClient->Reset();
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to reset render stream.";
+ goto Exit;
+ }
+
+ // start the render stream
+ hr = renderAudioClient->Start();
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to start render stream.";
+ goto Exit;
+ }
+ }
+
+ unsigned int outBufferSize = 0;
+ hr = renderAudioClient->GetBufferSize( &outBufferSize );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to get render buffer size.";
+ goto Exit;
+ }
+
+ // scale inBufferSize according to user->stream sample rate ratio
+ unsigned int inBufferSize = ( unsigned int ) ceilf( stream_.bufferSize * renderSrRatio ) * stream_.nDeviceChannels[OUTPUT];
+ outBufferSize *= stream_.nDeviceChannels[OUTPUT];
+
+ // set renderBuffer size
+ renderBuffer.setBufferSize( inBufferSize + outBufferSize, formatBytes( stream_.deviceFormat[OUTPUT] ) );
+ }
+
+ // malloc buffer memory
+ if ( stream_.mode == INPUT )
+ {
+ using namespace std; // for ceilf
+ convBuffSize = ( size_t ) ( ceilf( stream_.bufferSize * captureSrRatio ) ) * stream_.nDeviceChannels[INPUT] * formatBytes( stream_.deviceFormat[INPUT] );
+ deviceBuffSize = stream_.bufferSize * stream_.nDeviceChannels[INPUT] * formatBytes( stream_.deviceFormat[INPUT] );
+ }
+ else if ( stream_.mode == OUTPUT )
+ {
+ convBuffSize = ( size_t ) ( ceilf( stream_.bufferSize * renderSrRatio ) ) * stream_.nDeviceChannels[OUTPUT] * formatBytes( stream_.deviceFormat[OUTPUT] );
+ deviceBuffSize = stream_.bufferSize * stream_.nDeviceChannels[OUTPUT] * formatBytes( stream_.deviceFormat[OUTPUT] );
+ }
+ else if ( stream_.mode == DUPLEX )
+ {
+ convBuffSize = std::max( ( size_t ) ( ceilf( stream_.bufferSize * captureSrRatio ) ) * stream_.nDeviceChannels[INPUT] * formatBytes( stream_.deviceFormat[INPUT] ),
+ ( size_t ) ( ceilf( stream_.bufferSize * renderSrRatio ) ) * stream_.nDeviceChannels[OUTPUT] * formatBytes( stream_.deviceFormat[OUTPUT] ) );
+ deviceBuffSize = std::max( stream_.bufferSize * stream_.nDeviceChannels[INPUT] * formatBytes( stream_.deviceFormat[INPUT] ),
+ stream_.bufferSize * stream_.nDeviceChannels[OUTPUT] * formatBytes( stream_.deviceFormat[OUTPUT] ) );
+ }
+
+ convBuffSize *= 2; // allow overflow for *SrRatio remainders
+ convBuffer = ( char* ) calloc( convBuffSize, 1 );
+ stream_.deviceBuffer = ( char* ) calloc( deviceBuffSize, 1 );
+ if ( !convBuffer || !stream_.deviceBuffer ) {
+ errorType = RtAudioError::MEMORY_ERROR;
+ errorText = "RtApiWasapi::wasapiThread: Error allocating device buffer memory.";
+ goto Exit;
+ }
+
+ // stream process loop
+ while ( stream_.state != STREAM_STOPPING ) {
+ if ( !callbackPulled ) {
+ // Callback Input
+ // ==============
+ // 1. Pull callback buffer from inputBuffer
+ // 2. If 1. was successful: Convert callback buffer to user sample rate and channel count
+ // Convert callback buffer to user format
+
+ if ( captureAudioClient )
+ {
+ int samplesToPull = ( unsigned int ) floorf( stream_.bufferSize * captureSrRatio );
+ if ( captureSrRatio != 1 )
+ {
+ // account for remainders
+ samplesToPull--;
+ }
+
+ convBufferSize = 0;
+ while ( convBufferSize < stream_.bufferSize )
+ {
+ // Pull callback buffer from inputBuffer
+ callbackPulled = captureBuffer.pullBuffer( convBuffer,
+ samplesToPull * stream_.nDeviceChannels[INPUT],
+ stream_.deviceFormat[INPUT] );
+
+ if ( !callbackPulled )
+ {
+ break;
+ }
+
+ // Convert callback buffer to user sample rate
+ unsigned int deviceBufferOffset = convBufferSize * stream_.nDeviceChannels[INPUT] * formatBytes( stream_.deviceFormat[INPUT] );
+ unsigned int convSamples = 0;
+
+ captureResampler->Convert( stream_.deviceBuffer + deviceBufferOffset,
+ convBuffer,
+ samplesToPull,
+ convSamples );
+
+ convBufferSize += convSamples;
+ samplesToPull = 1; // now pull one sample at a time until we have stream_.bufferSize samples
+ }
+
+ if ( callbackPulled )
+ {
+ if ( stream_.doConvertBuffer[INPUT] ) {
+ // Convert callback buffer to user format
+ convertBuffer( stream_.userBuffer[INPUT],
+ stream_.deviceBuffer,
+ stream_.convertInfo[INPUT] );
+ }
+ else {
+ // no further conversion, simple copy deviceBuffer to userBuffer
+ memcpy( stream_.userBuffer[INPUT],
+ stream_.deviceBuffer,
+ stream_.bufferSize * stream_.nUserChannels[INPUT] * formatBytes( stream_.userFormat ) );
+ }
+ }
+ }
+ else {
+ // if there is no capture stream, set callbackPulled flag
+ callbackPulled = true;
+ }
+
+ // Execute Callback
+ // ================
+ // 1. Execute user callback method
+ // 2. Handle return value from callback
+
+ // if callback has not requested the stream to stop
+ if ( callbackPulled && !callbackStopped ) {
+ // Execute user callback method
+ callbackResult = callback( stream_.userBuffer[OUTPUT],
+ stream_.userBuffer[INPUT],
+ stream_.bufferSize,
+ getStreamTime(),
+ captureFlags & AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY ? RTAUDIO_INPUT_OVERFLOW : 0,
+ stream_.callbackInfo.userData );
+
+ // tick stream time
+ RtApi::tickStreamTime();
+
+ // Handle return value from callback
+ if ( callbackResult == 1 ) {
+ // instantiate a thread to stop this thread
+ HANDLE threadHandle = CreateThread( NULL, 0, stopWasapiThread, this, 0, NULL );
+ if ( !threadHandle ) {
+ errorType = RtAudioError::THREAD_ERROR;
+ errorText = "RtApiWasapi::wasapiThread: Unable to instantiate stream stop thread.";
+ goto Exit;
+ }
+ else if ( !CloseHandle( threadHandle ) ) {
+ errorType = RtAudioError::THREAD_ERROR;
+ errorText = "RtApiWasapi::wasapiThread: Unable to close stream stop thread handle.";
+ goto Exit;
+ }
+
+ callbackStopped = true;
+ }
+ else if ( callbackResult == 2 ) {
+ // instantiate a thread to stop this thread
+ HANDLE threadHandle = CreateThread( NULL, 0, abortWasapiThread, this, 0, NULL );
+ if ( !threadHandle ) {
+ errorType = RtAudioError::THREAD_ERROR;
+ errorText = "RtApiWasapi::wasapiThread: Unable to instantiate stream abort thread.";
+ goto Exit;
+ }
+ else if ( !CloseHandle( threadHandle ) ) {
+ errorType = RtAudioError::THREAD_ERROR;
+ errorText = "RtApiWasapi::wasapiThread: Unable to close stream abort thread handle.";
+ goto Exit;
+ }
+
+ callbackStopped = true;
+ }
+ }
+ }
+
+ // Callback Output
+ // ===============
+ // 1. Convert callback buffer to stream format
+ // 2. Convert callback buffer to stream sample rate and channel count
+ // 3. Push callback buffer into outputBuffer
+
+ if ( renderAudioClient && callbackPulled )
+ {
+ // if the last call to renderBuffer.PushBuffer() was successful
+ if ( callbackPushed || convBufferSize == 0 )
+ {
+ if ( stream_.doConvertBuffer[OUTPUT] )
+ {
+ // Convert callback buffer to stream format
+ convertBuffer( stream_.deviceBuffer,
+ stream_.userBuffer[OUTPUT],
+ stream_.convertInfo[OUTPUT] );
+
+ }
+ else {
+ // no further conversion, simple copy userBuffer to deviceBuffer
+ memcpy( stream_.deviceBuffer,
+ stream_.userBuffer[OUTPUT],
+ stream_.bufferSize * stream_.nUserChannels[OUTPUT] * formatBytes( stream_.userFormat ) );
+ }
+
+ // Convert callback buffer to stream sample rate
+ renderResampler->Convert( convBuffer,
+ stream_.deviceBuffer,
+ stream_.bufferSize,
+ convBufferSize );
+ }
+
+ // Push callback buffer into outputBuffer
+ callbackPushed = renderBuffer.pushBuffer( convBuffer,
+ convBufferSize * stream_.nDeviceChannels[OUTPUT],
+ stream_.deviceFormat[OUTPUT] );
+ }
+ else {
+ // if there is no render stream, set callbackPushed flag
+ callbackPushed = true;
+ }
+
+ // Stream Capture
+ // ==============
+ // 1. Get capture buffer from stream
+ // 2. Push capture buffer into inputBuffer
+ // 3. If 2. was successful: Release capture buffer
+
+ if ( captureAudioClient ) {
+ // if the callback input buffer was not pulled from captureBuffer, wait for next capture event
+ if ( !callbackPulled ) {
+ WaitForSingleObject( loopbackEnabled ? renderEvent : captureEvent, INFINITE );
+ }
+
+ // Get capture buffer from stream
+ hr = captureClient->GetBuffer( &streamBuffer,
+ &bufferFrameCount,
+ &captureFlags, NULL, NULL );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to retrieve capture buffer.";
+ goto Exit;
+ }
+
+ if ( bufferFrameCount != 0 ) {
+ // Push capture buffer into inputBuffer
+ if ( captureBuffer.pushBuffer( ( char* ) streamBuffer,
+ bufferFrameCount * stream_.nDeviceChannels[INPUT],
+ stream_.deviceFormat[INPUT] ) )
+ {
+ // Release capture buffer
+ hr = captureClient->ReleaseBuffer( bufferFrameCount );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to release capture buffer.";
+ goto Exit;
+ }
+ }
+ else
+ {
+ // Inform WASAPI that capture was unsuccessful
+ hr = captureClient->ReleaseBuffer( 0 );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to release capture buffer.";
+ goto Exit;
+ }
+ }
+ }
+ else
+ {
+ // Inform WASAPI that capture was unsuccessful
+ hr = captureClient->ReleaseBuffer( 0 );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to release capture buffer.";
+ goto Exit;
+ }
+ }
+ }
+
+ // Stream Render
+ // =============
+ // 1. Get render buffer from stream
+ // 2. Pull next buffer from outputBuffer
+ // 3. If 2. was successful: Fill render buffer with next buffer
+ // Release render buffer
+
+ if ( renderAudioClient ) {
+ // if the callback output buffer was not pushed to renderBuffer, wait for next render event
+ if ( callbackPulled && !callbackPushed ) {
+ WaitForSingleObject( renderEvent, INFINITE );
+ }
+
+ // Get render buffer from stream
+ hr = renderAudioClient->GetBufferSize( &bufferFrameCount );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to retrieve render buffer size.";
+ goto Exit;
+ }
+
+ hr = renderAudioClient->GetCurrentPadding( &numFramesPadding );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to retrieve render buffer padding.";
+ goto Exit;
+ }
+
+ bufferFrameCount -= numFramesPadding;
+
+ if ( bufferFrameCount != 0 ) {
+ hr = renderClient->GetBuffer( bufferFrameCount, &streamBuffer );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to retrieve render buffer.";
+ goto Exit;
+ }
+
+ // Pull next buffer from outputBuffer
+ // Fill render buffer with next buffer
+ if ( renderBuffer.pullBuffer( ( char* ) streamBuffer,
+ bufferFrameCount * stream_.nDeviceChannels[OUTPUT],
+ stream_.deviceFormat[OUTPUT] ) )
+ {
+ // Release render buffer
+ hr = renderClient->ReleaseBuffer( bufferFrameCount, 0 );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to release render buffer.";
+ goto Exit;
+ }
+ }
+ else
+ {
+ // Inform WASAPI that render was unsuccessful
+ hr = renderClient->ReleaseBuffer( 0, 0 );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to release render buffer.";
+ goto Exit;
+ }
+ }
+ }
+ else
+ {
+ // Inform WASAPI that render was unsuccessful
+ hr = renderClient->ReleaseBuffer( 0, 0 );
+ if ( FAILED( hr ) ) {
+ errorText = "RtApiWasapi::wasapiThread: Unable to release render buffer.";
+ goto Exit;
+ }
+ }
+ }
+
+ // if the callback buffer was pushed renderBuffer reset callbackPulled flag
+ if ( callbackPushed ) {
+ // unsetting the callbackPulled flag lets the stream know that
+ // the audio device is ready for another callback output buffer.
+ callbackPulled = false;
+ }
+
+ }
+
+Exit:
+ // clean up
+ CoTaskMemFree( captureFormat );
+ CoTaskMemFree( renderFormat );
+
+ free ( convBuffer );
+ delete renderResampler;
+ delete captureResampler;
+
+ CoUninitialize();
+
+ // update stream state
+ stream_.state = STREAM_STOPPED;
+
+ if ( !errorText.empty() )
+ {
+ errorText_ = errorText;
+ error( errorType );
+ }
+}
+
+//******************** End of __WINDOWS_WASAPI__ *********************//
+#endif
+
+
+#if defined(__WINDOWS_DS__) // Windows DirectSound API
+
+// Modified by Robin Davies, October 2005
+// - Improvements to DirectX pointer chasing.
+// - Bug fix for non-power-of-two Asio granularity used by Edirol PCR-A30.
+// - Auto-call CoInitialize for DSOUND and ASIO platforms.
+// Various revisions for RtAudio 4.0 by Gary Scavone, April 2007
+// Changed device query structure for RtAudio 4.0.7, January 2010
+
+#include <windows.h>
+#include <process.h>
+#include <mmsystem.h>
+#include <mmreg.h>
+#include <dsound.h>
+#include <assert.h>
+#include <algorithm>
+
+#if defined(__MINGW32__)
+ // missing from latest mingw winapi
+#define WAVE_FORMAT_96M08 0x00010000 /* 96 kHz, Mono, 8-bit */
+#define WAVE_FORMAT_96S08 0x00020000 /* 96 kHz, Stereo, 8-bit */
+#define WAVE_FORMAT_96M16 0x00040000 /* 96 kHz, Mono, 16-bit */
+#define WAVE_FORMAT_96S16 0x00080000 /* 96 kHz, Stereo, 16-bit */
+#endif
+
+#define MINIMUM_DEVICE_BUFFER_SIZE 32768
+
+#ifdef _MSC_VER // if Microsoft Visual C++
+#pragma comment( lib, "winmm.lib" ) // then, auto-link winmm.lib. Otherwise, it has to be added manually.
+#endif
+
+static inline DWORD dsPointerBetween( DWORD pointer, DWORD laterPointer, DWORD earlierPointer, DWORD bufferSize )
+{
+ if ( pointer > bufferSize ) pointer -= bufferSize;
+ if ( laterPointer < earlierPointer ) laterPointer += bufferSize;
+ if ( pointer < earlierPointer ) pointer += bufferSize;
+ return pointer >= earlierPointer && pointer < laterPointer;
+}
+
+// A structure to hold various information related to the DirectSound
+// API implementation.
+struct DsHandle {
+ unsigned int drainCounter; // Tracks callback counts when draining
+ bool internalDrain; // Indicates if stop is initiated from callback or not.
+ void *id[2];
+ void *buffer[2];
+ bool xrun[2];
+ UINT bufferPointer[2];
+ DWORD dsBufferSize[2];
+ DWORD dsPointerLeadTime[2]; // the number of bytes ahead of the safe pointer to lead by.
+ HANDLE condition;
+
+ DsHandle()
+ :drainCounter(0), internalDrain(false) { id[0] = 0; id[1] = 0; buffer[0] = 0; buffer[1] = 0; xrun[0] = false; xrun[1] = false; bufferPointer[0] = 0; bufferPointer[1] = 0; }
+};
+
+// Declarations for utility functions, callbacks, and structures
+// specific to the DirectSound implementation.
+static BOOL CALLBACK deviceQueryCallback( LPGUID lpguid,
+ LPCTSTR description,
+ LPCTSTR module,
+ LPVOID lpContext );
+
+static const char* getErrorString( int code );
+
+static unsigned __stdcall callbackHandler( void *ptr );
+
+struct DsDevice {
+ LPGUID id[2];
+ bool validId[2];
+ bool found;
+ std::string name;
+
+ DsDevice()
+ : found(false) { validId[0] = false; validId[1] = false; }
+};
+
+struct DsProbeData {
+ bool isInput;
+ std::vector<struct DsDevice>* dsDevices;
+};
+
+RtApiDs :: RtApiDs()
+{
+ // Dsound will run both-threaded. If CoInitialize fails, then just
+ // accept whatever the mainline chose for a threading model.
+ coInitialized_ = false;
+ HRESULT hr = CoInitialize( NULL );
+ if ( !FAILED( hr ) ) coInitialized_ = true;
+}
+
+RtApiDs :: ~RtApiDs()
+{
+ if ( stream_.state != STREAM_CLOSED ) closeStream();
+ if ( coInitialized_ ) CoUninitialize(); // balanced call.
+}
+
+// The DirectSound default output is always the first device.
+unsigned int RtApiDs :: getDefaultOutputDevice( void )
+{
+ return 0;
+}
+
+// The DirectSound default input is always the first input device,
+// which is the first capture device enumerated.
+unsigned int RtApiDs :: getDefaultInputDevice( void )
+{
+ return 0;
+}
+
+unsigned int RtApiDs :: getDeviceCount( void )
+{
+ // Set query flag for previously found devices to false, so that we
+ // can check for any devices that have disappeared.
+ for ( unsigned int i=0; i<dsDevices.size(); i++ )
+ dsDevices[i].found = false;
+
+ // Query DirectSound devices.
+ struct DsProbeData probeInfo;
+ probeInfo.isInput = false;
+ probeInfo.dsDevices = &dsDevices;
+ HRESULT result = DirectSoundEnumerate( (LPDSENUMCALLBACK) deviceQueryCallback, &probeInfo );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::getDeviceCount: error (" << getErrorString( result ) << ") enumerating output devices!";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ }
+
+ // Query DirectSoundCapture devices.
+ probeInfo.isInput = true;
+ result = DirectSoundCaptureEnumerate( (LPDSENUMCALLBACK) deviceQueryCallback, &probeInfo );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::getDeviceCount: error (" << getErrorString( result ) << ") enumerating input devices!";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ }
+
+ // Clean out any devices that may have disappeared (code update submitted by Eli Zehngut).
+ for ( unsigned int i=0; i<dsDevices.size(); ) {
+ if ( dsDevices[i].found == false ) dsDevices.erase( dsDevices.begin() + i );
+ else i++;
+ }
+
+ return static_cast<unsigned int>(dsDevices.size());
+}
+
+RtAudio::DeviceInfo RtApiDs :: getDeviceInfo( unsigned int device )
+{
+ RtAudio::DeviceInfo info;
+ info.probed = false;
+
+ if ( dsDevices.size() == 0 ) {
+ // Force a query of all devices
+ getDeviceCount();
+ if ( dsDevices.size() == 0 ) {
+ errorText_ = "RtApiDs::getDeviceInfo: no devices found!";
+ error( RtAudioError::INVALID_USE );
+ return info;
+ }
+ }
+
+ if ( device >= dsDevices.size() ) {
+ errorText_ = "RtApiDs::getDeviceInfo: device ID is invalid!";
+ error( RtAudioError::INVALID_USE );
+ return info;
+ }
+
+ HRESULT result;
+ if ( dsDevices[ device ].validId[0] == false ) goto probeInput;
+
+ LPDIRECTSOUND output;
+ DSCAPS outCaps;
+ result = DirectSoundCreate( dsDevices[ device ].id[0], &output, NULL );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") opening output device (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ goto probeInput;
+ }
+
+ outCaps.dwSize = sizeof( outCaps );
+ result = output->GetCaps( &outCaps );
+ if ( FAILED( result ) ) {
+ output->Release();
+ errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") getting capabilities!";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ goto probeInput;
+ }
+
+ // Get output channel information.
+ info.outputChannels = ( outCaps.dwFlags & DSCAPS_PRIMARYSTEREO ) ? 2 : 1;
+
+ // Get sample rate information.
+ info.sampleRates.clear();
+ for ( unsigned int k=0; k<MAX_SAMPLE_RATES; k++ ) {
+ if ( SAMPLE_RATES[k] >= (unsigned int) outCaps.dwMinSecondarySampleRate &&
+ SAMPLE_RATES[k] <= (unsigned int) outCaps.dwMaxSecondarySampleRate ) {
+ info.sampleRates.push_back( SAMPLE_RATES[k] );
+
+ if ( !info.preferredSampleRate || ( SAMPLE_RATES[k] <= 48000 && SAMPLE_RATES[k] > info.preferredSampleRate ) )
+ info.preferredSampleRate = SAMPLE_RATES[k];
+ }
+ }
+
+ // Get format information.
+ if ( outCaps.dwFlags & DSCAPS_PRIMARY16BIT ) info.nativeFormats |= RTAUDIO_SINT16;
+ if ( outCaps.dwFlags & DSCAPS_PRIMARY8BIT ) info.nativeFormats |= RTAUDIO_SINT8;
+
+ output->Release();
+
+ if ( getDefaultOutputDevice() == device )
+ info.isDefaultOutput = true;
+
+ if ( dsDevices[ device ].validId[1] == false ) {
+ info.name = dsDevices[ device ].name;
+ info.probed = true;
+ return info;
+ }
+
+ probeInput:
+
+ LPDIRECTSOUNDCAPTURE input;
+ result = DirectSoundCaptureCreate( dsDevices[ device ].id[1], &input, NULL );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") opening input device (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ DSCCAPS inCaps;
+ inCaps.dwSize = sizeof( inCaps );
+ result = input->GetCaps( &inCaps );
+ if ( FAILED( result ) ) {
+ input->Release();
+ errorStream_ << "RtApiDs::getDeviceInfo: error (" << getErrorString( result ) << ") getting object capabilities (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // Get input channel information.
+ info.inputChannels = inCaps.dwChannels;
+
+ // Get sample rate and format information.
+ std::vector<unsigned int> rates;
+ if ( inCaps.dwChannels >= 2 ) {
+ if ( inCaps.dwFormats & WAVE_FORMAT_1S16 ) info.nativeFormats |= RTAUDIO_SINT16;
+ if ( inCaps.dwFormats & WAVE_FORMAT_2S16 ) info.nativeFormats |= RTAUDIO_SINT16;
+ if ( inCaps.dwFormats & WAVE_FORMAT_4S16 ) info.nativeFormats |= RTAUDIO_SINT16;
+ if ( inCaps.dwFormats & WAVE_FORMAT_96S16 ) info.nativeFormats |= RTAUDIO_SINT16;
+ if ( inCaps.dwFormats & WAVE_FORMAT_1S08 ) info.nativeFormats |= RTAUDIO_SINT8;
+ if ( inCaps.dwFormats & WAVE_FORMAT_2S08 ) info.nativeFormats |= RTAUDIO_SINT8;
+ if ( inCaps.dwFormats & WAVE_FORMAT_4S08 ) info.nativeFormats |= RTAUDIO_SINT8;
+ if ( inCaps.dwFormats & WAVE_FORMAT_96S08 ) info.nativeFormats |= RTAUDIO_SINT8;
+
+ if ( info.nativeFormats & RTAUDIO_SINT16 ) {
+ if ( inCaps.dwFormats & WAVE_FORMAT_1S16 ) rates.push_back( 11025 );
+ if ( inCaps.dwFormats & WAVE_FORMAT_2S16 ) rates.push_back( 22050 );
+ if ( inCaps.dwFormats & WAVE_FORMAT_4S16 ) rates.push_back( 44100 );
+ if ( inCaps.dwFormats & WAVE_FORMAT_96S16 ) rates.push_back( 96000 );
+ }
+ else if ( info.nativeFormats & RTAUDIO_SINT8 ) {
+ if ( inCaps.dwFormats & WAVE_FORMAT_1S08 ) rates.push_back( 11025 );
+ if ( inCaps.dwFormats & WAVE_FORMAT_2S08 ) rates.push_back( 22050 );
+ if ( inCaps.dwFormats & WAVE_FORMAT_4S08 ) rates.push_back( 44100 );
+ if ( inCaps.dwFormats & WAVE_FORMAT_96S08 ) rates.push_back( 96000 );
+ }
+ }
+ else if ( inCaps.dwChannels == 1 ) {
+ if ( inCaps.dwFormats & WAVE_FORMAT_1M16 ) info.nativeFormats |= RTAUDIO_SINT16;
+ if ( inCaps.dwFormats & WAVE_FORMAT_2M16 ) info.nativeFormats |= RTAUDIO_SINT16;
+ if ( inCaps.dwFormats & WAVE_FORMAT_4M16 ) info.nativeFormats |= RTAUDIO_SINT16;
+ if ( inCaps.dwFormats & WAVE_FORMAT_96M16 ) info.nativeFormats |= RTAUDIO_SINT16;
+ if ( inCaps.dwFormats & WAVE_FORMAT_1M08 ) info.nativeFormats |= RTAUDIO_SINT8;
+ if ( inCaps.dwFormats & WAVE_FORMAT_2M08 ) info.nativeFormats |= RTAUDIO_SINT8;
+ if ( inCaps.dwFormats & WAVE_FORMAT_4M08 ) info.nativeFormats |= RTAUDIO_SINT8;
+ if ( inCaps.dwFormats & WAVE_FORMAT_96M08 ) info.nativeFormats |= RTAUDIO_SINT8;
+
+ if ( info.nativeFormats & RTAUDIO_SINT16 ) {
+ if ( inCaps.dwFormats & WAVE_FORMAT_1M16 ) rates.push_back( 11025 );
+ if ( inCaps.dwFormats & WAVE_FORMAT_2M16 ) rates.push_back( 22050 );
+ if ( inCaps.dwFormats & WAVE_FORMAT_4M16 ) rates.push_back( 44100 );
+ if ( inCaps.dwFormats & WAVE_FORMAT_96M16 ) rates.push_back( 96000 );
+ }
+ else if ( info.nativeFormats & RTAUDIO_SINT8 ) {
+ if ( inCaps.dwFormats & WAVE_FORMAT_1M08 ) rates.push_back( 11025 );
+ if ( inCaps.dwFormats & WAVE_FORMAT_2M08 ) rates.push_back( 22050 );
+ if ( inCaps.dwFormats & WAVE_FORMAT_4M08 ) rates.push_back( 44100 );
+ if ( inCaps.dwFormats & WAVE_FORMAT_96M08 ) rates.push_back( 96000 );
+ }
+ }
+ else info.inputChannels = 0; // technically, this would be an error
+
+ input->Release();
+
+ if ( info.inputChannels == 0 ) return info;
+
+ // Copy the supported rates to the info structure but avoid duplication.
+ bool found;
+ for ( unsigned int i=0; i<rates.size(); i++ ) {
+ found = false;
+ for ( unsigned int j=0; j<info.sampleRates.size(); j++ ) {
+ if ( rates[i] == info.sampleRates[j] ) {
+ found = true;
+ break;
+ }
+ }
+ if ( found == false ) info.sampleRates.push_back( rates[i] );
+ }
+ std::sort( info.sampleRates.begin(), info.sampleRates.end() );
+
+ // If device opens for both playback and capture, we determine the channels.
+ if ( info.outputChannels > 0 && info.inputChannels > 0 )
+ info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels;
+
+ if ( device == 0 ) info.isDefaultInput = true;
+
+ // Copy name and return.
+ info.name = dsDevices[ device ].name;
+ info.probed = true;
+ return info;
+}
+
+bool RtApiDs :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options )
+{
+ if ( channels + firstChannel > 2 ) {
+ errorText_ = "RtApiDs::probeDeviceOpen: DirectSound does not support more than 2 channels per device.";
+ return FAILURE;
+ }
+
+ size_t nDevices = dsDevices.size();
+ if ( nDevices == 0 ) {
+ // This should not happen because a check is made before this function is called.
+ errorText_ = "RtApiDs::probeDeviceOpen: no devices found!";
+ return FAILURE;
+ }
+
+ if ( device >= nDevices ) {
+ // This should not happen because a check is made before this function is called.
+ errorText_ = "RtApiDs::probeDeviceOpen: device ID is invalid!";
+ return FAILURE;
+ }
+
+ if ( mode == OUTPUT ) {
+ if ( dsDevices[ device ].validId[0] == false ) {
+ errorStream_ << "RtApiDs::probeDeviceOpen: device (" << device << ") does not support output!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ }
+ else { // mode == INPUT
+ if ( dsDevices[ device ].validId[1] == false ) {
+ errorStream_ << "RtApiDs::probeDeviceOpen: device (" << device << ") does not support input!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ }
+
+ // According to a note in PortAudio, using GetDesktopWindow()
+ // instead of GetForegroundWindow() is supposed to avoid problems
+ // that occur when the application's window is not the foreground
+ // window. Also, if the application window closes before the
+ // DirectSound buffer, DirectSound can crash. In the past, I had
+ // problems when using GetDesktopWindow() but it seems fine now
+ // (January 2010). I'll leave it commented here.
+ // HWND hWnd = GetForegroundWindow();
+ HWND hWnd = GetDesktopWindow();
+
+ // Check the numberOfBuffers parameter and limit the lowest value to
+ // two. This is a judgement call and a value of two is probably too
+ // low for capture, but it should work for playback.
+ int nBuffers = 0;
+ if ( options ) nBuffers = options->numberOfBuffers;
+ if ( options && options->flags & RTAUDIO_MINIMIZE_LATENCY ) nBuffers = 2;
+ if ( nBuffers < 2 ) nBuffers = 3;
+
+ // Check the lower range of the user-specified buffer size and set
+ // (arbitrarily) to a lower bound of 32.
+ if ( *bufferSize < 32 ) *bufferSize = 32;
+
+ // Create the wave format structure. The data format setting will
+ // be determined later.
+ WAVEFORMATEX waveFormat;
+ ZeroMemory( &waveFormat, sizeof(WAVEFORMATEX) );
+ waveFormat.wFormatTag = WAVE_FORMAT_PCM;
+ waveFormat.nChannels = channels + firstChannel;
+ waveFormat.nSamplesPerSec = (unsigned long) sampleRate;
+
+ // Determine the device buffer size. By default, we'll use the value
+ // defined above (32K), but we will grow it to make allowances for
+ // very large software buffer sizes.
+ DWORD dsBufferSize = MINIMUM_DEVICE_BUFFER_SIZE;
+ DWORD dsPointerLeadTime = 0;
+
+ void *ohandle = 0, *bhandle = 0;
+ HRESULT result;
+ if ( mode == OUTPUT ) {
+
+ LPDIRECTSOUND output;
+ result = DirectSoundCreate( dsDevices[ device ].id[0], &output, NULL );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") opening output device (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ DSCAPS outCaps;
+ outCaps.dwSize = sizeof( outCaps );
+ result = output->GetCaps( &outCaps );
+ if ( FAILED( result ) ) {
+ output->Release();
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") getting capabilities (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Check channel information.
+ if ( channels + firstChannel == 2 && !( outCaps.dwFlags & DSCAPS_PRIMARYSTEREO ) ) {
+ errorStream_ << "RtApiDs::getDeviceInfo: the output device (" << dsDevices[ device ].name << ") does not support stereo playback.";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Check format information. Use 16-bit format unless not
+ // supported or user requests 8-bit.
+ if ( outCaps.dwFlags & DSCAPS_PRIMARY16BIT &&
+ !( format == RTAUDIO_SINT8 && outCaps.dwFlags & DSCAPS_PRIMARY8BIT ) ) {
+ waveFormat.wBitsPerSample = 16;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT16;
+ }
+ else {
+ waveFormat.wBitsPerSample = 8;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT8;
+ }
+ stream_.userFormat = format;
+
+ // Update wave format structure and buffer information.
+ waveFormat.nBlockAlign = waveFormat.nChannels * waveFormat.wBitsPerSample / 8;
+ waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
+ dsPointerLeadTime = nBuffers * (*bufferSize) * (waveFormat.wBitsPerSample / 8) * channels;
+
+ // If the user wants an even bigger buffer, increase the device buffer size accordingly.
+ while ( dsPointerLeadTime * 2U > dsBufferSize )
+ dsBufferSize *= 2;
+
+ // Set cooperative level to DSSCL_EXCLUSIVE ... sound stops when window focus changes.
+ // result = output->SetCooperativeLevel( hWnd, DSSCL_EXCLUSIVE );
+ // Set cooperative level to DSSCL_PRIORITY ... sound remains when window focus changes.
+ result = output->SetCooperativeLevel( hWnd, DSSCL_PRIORITY );
+ if ( FAILED( result ) ) {
+ output->Release();
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") setting cooperative level (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Even though we will write to the secondary buffer, we need to
+ // access the primary buffer to set the correct output format
+ // (since the default is 8-bit, 22 kHz!). Setup the DS primary
+ // buffer description.
+ DSBUFFERDESC bufferDescription;
+ ZeroMemory( &bufferDescription, sizeof( DSBUFFERDESC ) );
+ bufferDescription.dwSize = sizeof( DSBUFFERDESC );
+ bufferDescription.dwFlags = DSBCAPS_PRIMARYBUFFER;
+
+ // Obtain the primary buffer
+ LPDIRECTSOUNDBUFFER buffer;
+ result = output->CreateSoundBuffer( &bufferDescription, &buffer, NULL );
+ if ( FAILED( result ) ) {
+ output->Release();
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") accessing primary buffer (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Set the primary DS buffer sound format.
+ result = buffer->SetFormat( &waveFormat );
+ if ( FAILED( result ) ) {
+ output->Release();
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") setting primary buffer format (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Setup the secondary DS buffer description.
+ ZeroMemory( &bufferDescription, sizeof( DSBUFFERDESC ) );
+ bufferDescription.dwSize = sizeof( DSBUFFERDESC );
+ bufferDescription.dwFlags = ( DSBCAPS_STICKYFOCUS |
+ DSBCAPS_GLOBALFOCUS |
+ DSBCAPS_GETCURRENTPOSITION2 |
+ DSBCAPS_LOCHARDWARE ); // Force hardware mixing
+ bufferDescription.dwBufferBytes = dsBufferSize;
+ bufferDescription.lpwfxFormat = &waveFormat;
+
+ // Try to create the secondary DS buffer. If that doesn't work,
+ // try to use software mixing. Otherwise, there's a problem.
+ result = output->CreateSoundBuffer( &bufferDescription, &buffer, NULL );
+ if ( FAILED( result ) ) {
+ bufferDescription.dwFlags = ( DSBCAPS_STICKYFOCUS |
+ DSBCAPS_GLOBALFOCUS |
+ DSBCAPS_GETCURRENTPOSITION2 |
+ DSBCAPS_LOCSOFTWARE ); // Force software mixing
+ result = output->CreateSoundBuffer( &bufferDescription, &buffer, NULL );
+ if ( FAILED( result ) ) {
+ output->Release();
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") creating secondary buffer (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ }
+
+ // Get the buffer size ... might be different from what we specified.
+ DSBCAPS dsbcaps;
+ dsbcaps.dwSize = sizeof( DSBCAPS );
+ result = buffer->GetCaps( &dsbcaps );
+ if ( FAILED( result ) ) {
+ output->Release();
+ buffer->Release();
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") getting buffer settings (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ dsBufferSize = dsbcaps.dwBufferBytes;
+
+ // Lock the DS buffer
+ LPVOID audioPtr;
+ DWORD dataLen;
+ result = buffer->Lock( 0, dsBufferSize, &audioPtr, &dataLen, NULL, NULL, 0 );
+ if ( FAILED( result ) ) {
+ output->Release();
+ buffer->Release();
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") locking buffer (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Zero the DS buffer
+ ZeroMemory( audioPtr, dataLen );
+
+ // Unlock the DS buffer
+ result = buffer->Unlock( audioPtr, dataLen, NULL, 0 );
+ if ( FAILED( result ) ) {
+ output->Release();
+ buffer->Release();
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") unlocking buffer (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ ohandle = (void *) output;
+ bhandle = (void *) buffer;
+ }
+
+ if ( mode == INPUT ) {
+
+ LPDIRECTSOUNDCAPTURE input;
+ result = DirectSoundCaptureCreate( dsDevices[ device ].id[1], &input, NULL );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") opening input device (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ DSCCAPS inCaps;
+ inCaps.dwSize = sizeof( inCaps );
+ result = input->GetCaps( &inCaps );
+ if ( FAILED( result ) ) {
+ input->Release();
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") getting input capabilities (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Check channel information.
+ if ( inCaps.dwChannels < channels + firstChannel ) {
+ errorText_ = "RtApiDs::getDeviceInfo: the input device does not support requested input channels.";
+ return FAILURE;
+ }
+
+ // Check format information. Use 16-bit format unless user
+ // requests 8-bit.
+ DWORD deviceFormats;
+ if ( channels + firstChannel == 2 ) {
+ deviceFormats = WAVE_FORMAT_1S08 | WAVE_FORMAT_2S08 | WAVE_FORMAT_4S08 | WAVE_FORMAT_96S08;
+ if ( format == RTAUDIO_SINT8 && inCaps.dwFormats & deviceFormats ) {
+ waveFormat.wBitsPerSample = 8;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT8;
+ }
+ else { // assume 16-bit is supported
+ waveFormat.wBitsPerSample = 16;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT16;
+ }
+ }
+ else { // channel == 1
+ deviceFormats = WAVE_FORMAT_1M08 | WAVE_FORMAT_2M08 | WAVE_FORMAT_4M08 | WAVE_FORMAT_96M08;
+ if ( format == RTAUDIO_SINT8 && inCaps.dwFormats & deviceFormats ) {
+ waveFormat.wBitsPerSample = 8;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT8;
+ }
+ else { // assume 16-bit is supported
+ waveFormat.wBitsPerSample = 16;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT16;
+ }
+ }
+ stream_.userFormat = format;
+
+ // Update wave format structure and buffer information.
+ waveFormat.nBlockAlign = waveFormat.nChannels * waveFormat.wBitsPerSample / 8;
+ waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
+ dsPointerLeadTime = nBuffers * (*bufferSize) * (waveFormat.wBitsPerSample / 8) * channels;
+
+ // If the user wants an even bigger buffer, increase the device buffer size accordingly.
+ while ( dsPointerLeadTime * 2U > dsBufferSize )
+ dsBufferSize *= 2;
+
+ // Setup the secondary DS buffer description.
+ DSCBUFFERDESC bufferDescription;
+ ZeroMemory( &bufferDescription, sizeof( DSCBUFFERDESC ) );
+ bufferDescription.dwSize = sizeof( DSCBUFFERDESC );
+ bufferDescription.dwFlags = 0;
+ bufferDescription.dwReserved = 0;
+ bufferDescription.dwBufferBytes = dsBufferSize;
+ bufferDescription.lpwfxFormat = &waveFormat;
+
+ // Create the capture buffer.
+ LPDIRECTSOUNDCAPTUREBUFFER buffer;
+ result = input->CreateCaptureBuffer( &bufferDescription, &buffer, NULL );
+ if ( FAILED( result ) ) {
+ input->Release();
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") creating input buffer (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Get the buffer size ... might be different from what we specified.
+ DSCBCAPS dscbcaps;
+ dscbcaps.dwSize = sizeof( DSCBCAPS );
+ result = buffer->GetCaps( &dscbcaps );
+ if ( FAILED( result ) ) {
+ input->Release();
+ buffer->Release();
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") getting buffer settings (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ dsBufferSize = dscbcaps.dwBufferBytes;
+
+ // NOTE: We could have a problem here if this is a duplex stream
+ // and the play and capture hardware buffer sizes are different
+ // (I'm actually not sure if that is a problem or not).
+ // Currently, we are not verifying that.
+
+ // Lock the capture buffer
+ LPVOID audioPtr;
+ DWORD dataLen;
+ result = buffer->Lock( 0, dsBufferSize, &audioPtr, &dataLen, NULL, NULL, 0 );
+ if ( FAILED( result ) ) {
+ input->Release();
+ buffer->Release();
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") locking input buffer (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Zero the buffer
+ ZeroMemory( audioPtr, dataLen );
+
+ // Unlock the buffer
+ result = buffer->Unlock( audioPtr, dataLen, NULL, 0 );
+ if ( FAILED( result ) ) {
+ input->Release();
+ buffer->Release();
+ errorStream_ << "RtApiDs::probeDeviceOpen: error (" << getErrorString( result ) << ") unlocking input buffer (" << dsDevices[ device ].name << ")!";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ ohandle = (void *) input;
+ bhandle = (void *) buffer;
+ }
+
+ // Set various stream parameters
+ DsHandle *handle = 0;
+ stream_.nDeviceChannels[mode] = channels + firstChannel;
+ stream_.nUserChannels[mode] = channels;
+ stream_.bufferSize = *bufferSize;
+ stream_.channelOffset[mode] = firstChannel;
+ stream_.deviceInterleaved[mode] = true;
+ if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false;
+ else stream_.userInterleaved = true;
+
+ // Set flag for buffer conversion
+ stream_.doConvertBuffer[mode] = false;
+ if (stream_.nUserChannels[mode] != stream_.nDeviceChannels[mode])
+ stream_.doConvertBuffer[mode] = true;
+ if (stream_.userFormat != stream_.deviceFormat[mode])
+ stream_.doConvertBuffer[mode] = true;
+ if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] &&
+ stream_.nUserChannels[mode] > 1 )
+ stream_.doConvertBuffer[mode] = true;
+
+ // Allocate necessary internal buffers
+ long bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
+ stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
+ if ( stream_.userBuffer[mode] == NULL ) {
+ errorText_ = "RtApiDs::probeDeviceOpen: error allocating user buffer memory.";
+ goto error;
+ }
+
+ if ( stream_.doConvertBuffer[mode] ) {
+
+ bool makeBuffer = true;
+ bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] );
+ if ( mode == INPUT ) {
+ if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) {
+ unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
+ if ( bufferBytes <= (long) bytesOut ) makeBuffer = false;
+ }
+ }
+
+ if ( makeBuffer ) {
+ bufferBytes *= *bufferSize;
+ if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
+ stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
+ if ( stream_.deviceBuffer == NULL ) {
+ errorText_ = "RtApiDs::probeDeviceOpen: error allocating device buffer memory.";
+ goto error;
+ }
+ }
+ }
+
+ // Allocate our DsHandle structures for the stream.
+ if ( stream_.apiHandle == 0 ) {
+ try {
+ handle = new DsHandle;
+ }
+ catch ( std::bad_alloc& ) {
+ errorText_ = "RtApiDs::probeDeviceOpen: error allocating AsioHandle memory.";
+ goto error;
+ }
+
+ // Create a manual-reset event.
+ handle->condition = CreateEvent( NULL, // no security
+ TRUE, // manual-reset
+ FALSE, // non-signaled initially
+ NULL ); // unnamed
+ stream_.apiHandle = (void *) handle;
+ }
+ else
+ handle = (DsHandle *) stream_.apiHandle;
+ handle->id[mode] = ohandle;
+ handle->buffer[mode] = bhandle;
+ handle->dsBufferSize[mode] = dsBufferSize;
+ handle->dsPointerLeadTime[mode] = dsPointerLeadTime;
+
+ stream_.device[mode] = device;
+ stream_.state = STREAM_STOPPED;
+ if ( stream_.mode == OUTPUT && mode == INPUT )
+ // We had already set up an output stream.
+ stream_.mode = DUPLEX;
+ else
+ stream_.mode = mode;
+ stream_.nBuffers = nBuffers;
+ stream_.sampleRate = sampleRate;
+
+ // Setup the buffer conversion information structure.
+ if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, firstChannel );
+
+ // Setup the callback thread.
+ if ( stream_.callbackInfo.isRunning == false ) {
+ unsigned threadId;
+ stream_.callbackInfo.isRunning = true;
+ stream_.callbackInfo.object = (void *) this;
+ stream_.callbackInfo.thread = _beginthreadex( NULL, 0, &callbackHandler,
+ &stream_.callbackInfo, 0, &threadId );
+ if ( stream_.callbackInfo.thread == 0 ) {
+ errorText_ = "RtApiDs::probeDeviceOpen: error creating callback thread!";
+ goto error;
+ }
+
+ // Boost DS thread priority
+ SetThreadPriority( (HANDLE) stream_.callbackInfo.thread, THREAD_PRIORITY_HIGHEST );
+ }
+ return SUCCESS;
+
+ error:
+ if ( handle ) {
+ if ( handle->buffer[0] ) { // the object pointer can be NULL and valid
+ LPDIRECTSOUND object = (LPDIRECTSOUND) handle->id[0];
+ LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
+ if ( buffer ) buffer->Release();
+ object->Release();
+ }
+ if ( handle->buffer[1] ) {
+ LPDIRECTSOUNDCAPTURE object = (LPDIRECTSOUNDCAPTURE) handle->id[1];
+ LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1];
+ if ( buffer ) buffer->Release();
+ object->Release();
+ }
+ CloseHandle( handle->condition );
+ delete handle;
+ stream_.apiHandle = 0;
+ }
+
+ for ( int i=0; i<2; i++ ) {
+ if ( stream_.userBuffer[i] ) {
+ free( stream_.userBuffer[i] );
+ stream_.userBuffer[i] = 0;
+ }
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+
+ stream_.state = STREAM_CLOSED;
+ return FAILURE;
+}
+
+void RtApiDs :: closeStream()
+{
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiDs::closeStream(): no open stream to close!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ // Stop the callback thread.
+ stream_.callbackInfo.isRunning = false;
+ WaitForSingleObject( (HANDLE) stream_.callbackInfo.thread, INFINITE );
+ CloseHandle( (HANDLE) stream_.callbackInfo.thread );
+
+ DsHandle *handle = (DsHandle *) stream_.apiHandle;
+ if ( handle ) {
+ if ( handle->buffer[0] ) { // the object pointer can be NULL and valid
+ LPDIRECTSOUND object = (LPDIRECTSOUND) handle->id[0];
+ LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
+ if ( buffer ) {
+ buffer->Stop();
+ buffer->Release();
+ }
+ object->Release();
+ }
+ if ( handle->buffer[1] ) {
+ LPDIRECTSOUNDCAPTURE object = (LPDIRECTSOUNDCAPTURE) handle->id[1];
+ LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1];
+ if ( buffer ) {
+ buffer->Stop();
+ buffer->Release();
+ }
+ object->Release();
+ }
+ CloseHandle( handle->condition );
+ delete handle;
+ stream_.apiHandle = 0;
+ }
+
+ for ( int i=0; i<2; i++ ) {
+ if ( stream_.userBuffer[i] ) {
+ free( stream_.userBuffer[i] );
+ stream_.userBuffer[i] = 0;
+ }
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+
+ stream_.mode = UNINITIALIZED;
+ stream_.state = STREAM_CLOSED;
+}
+
+void RtApiDs :: startStream()
+{
+ verifyStream();
+ if ( stream_.state == STREAM_RUNNING ) {
+ errorText_ = "RtApiDs::startStream(): the stream is already running!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ #if defined( HAVE_GETTIMEOFDAY )
+ gettimeofday( &stream_.lastTickTimestamp, NULL );
+ #endif
+
+ DsHandle *handle = (DsHandle *) stream_.apiHandle;
+
+ // Increase scheduler frequency on lesser windows (a side-effect of
+ // increasing timer accuracy). On greater windows (Win2K or later),
+ // this is already in effect.
+ timeBeginPeriod( 1 );
+
+ buffersRolling = false;
+ duplexPrerollBytes = 0;
+
+ if ( stream_.mode == DUPLEX ) {
+ // 0.5 seconds of silence in DUPLEX mode while the devices spin up and synchronize.
+ duplexPrerollBytes = (int) ( 0.5 * stream_.sampleRate * formatBytes( stream_.deviceFormat[1] ) * stream_.nDeviceChannels[1] );
+ }
+
+ HRESULT result = 0;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+
+ LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
+ result = buffer->Play( 0, 0, DSBPLAY_LOOPING );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::startStream: error (" << getErrorString( result ) << ") starting output buffer!";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+
+ if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
+
+ LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1];
+ result = buffer->Start( DSCBSTART_LOOPING );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::startStream: error (" << getErrorString( result ) << ") starting input buffer!";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+
+ handle->drainCounter = 0;
+ handle->internalDrain = false;
+ ResetEvent( handle->condition );
+ stream_.state = STREAM_RUNNING;
+
+ unlock:
+ if ( FAILED( result ) ) error( RtAudioError::SYSTEM_ERROR );
+}
+
+void RtApiDs :: stopStream()
+{
+ verifyStream();
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiDs::stopStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ HRESULT result = 0;
+ LPVOID audioPtr;
+ DWORD dataLen;
+ DsHandle *handle = (DsHandle *) stream_.apiHandle;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+ if ( handle->drainCounter == 0 ) {
+ handle->drainCounter = 2;
+ WaitForSingleObject( handle->condition, INFINITE ); // block until signaled
+ }
+
+ stream_.state = STREAM_STOPPED;
+
+ MUTEX_LOCK( &stream_.mutex );
+
+ // Stop the buffer and clear memory
+ LPDIRECTSOUNDBUFFER buffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
+ result = buffer->Stop();
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::stopStream: error (" << getErrorString( result ) << ") stopping output buffer!";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+
+ // Lock the buffer and clear it so that if we start to play again,
+ // we won't have old data playing.
+ result = buffer->Lock( 0, handle->dsBufferSize[0], &audioPtr, &dataLen, NULL, NULL, 0 );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::stopStream: error (" << getErrorString( result ) << ") locking output buffer!";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+
+ // Zero the DS buffer
+ ZeroMemory( audioPtr, dataLen );
+
+ // Unlock the DS buffer
+ result = buffer->Unlock( audioPtr, dataLen, NULL, 0 );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::stopStream: error (" << getErrorString( result ) << ") unlocking output buffer!";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+
+ // If we start playing again, we must begin at beginning of buffer.
+ handle->bufferPointer[0] = 0;
+ }
+
+ if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
+ LPDIRECTSOUNDCAPTUREBUFFER buffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1];
+ audioPtr = NULL;
+ dataLen = 0;
+
+ stream_.state = STREAM_STOPPED;
+
+ if ( stream_.mode != DUPLEX )
+ MUTEX_LOCK( &stream_.mutex );
+
+ result = buffer->Stop();
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::stopStream: error (" << getErrorString( result ) << ") stopping input buffer!";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+
+ // Lock the buffer and clear it so that if we start to play again,
+ // we won't have old data playing.
+ result = buffer->Lock( 0, handle->dsBufferSize[1], &audioPtr, &dataLen, NULL, NULL, 0 );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::stopStream: error (" << getErrorString( result ) << ") locking input buffer!";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+
+ // Zero the DS buffer
+ ZeroMemory( audioPtr, dataLen );
+
+ // Unlock the DS buffer
+ result = buffer->Unlock( audioPtr, dataLen, NULL, 0 );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::stopStream: error (" << getErrorString( result ) << ") unlocking input buffer!";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+
+ // If we start recording again, we must begin at beginning of buffer.
+ handle->bufferPointer[1] = 0;
+ }
+
+ unlock:
+ timeEndPeriod( 1 ); // revert to normal scheduler frequency on lesser windows.
+ MUTEX_UNLOCK( &stream_.mutex );
+
+ if ( FAILED( result ) ) error( RtAudioError::SYSTEM_ERROR );
+}
+
+void RtApiDs :: abortStream()
+{
+ verifyStream();
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiDs::abortStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ DsHandle *handle = (DsHandle *) stream_.apiHandle;
+ handle->drainCounter = 2;
+
+ stopStream();
+}
+
+void RtApiDs :: callbackEvent()
+{
+ if ( stream_.state == STREAM_STOPPED || stream_.state == STREAM_STOPPING ) {
+ Sleep( 50 ); // sleep 50 milliseconds
+ return;
+ }
+
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiDs::callbackEvent(): the stream is closed ... this shouldn't happen!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ CallbackInfo *info = (CallbackInfo *) &stream_.callbackInfo;
+ DsHandle *handle = (DsHandle *) stream_.apiHandle;
+
+ // Check if we were draining the stream and signal is finished.
+ if ( handle->drainCounter > stream_.nBuffers + 2 ) {
+
+ stream_.state = STREAM_STOPPING;
+ if ( handle->internalDrain == false )
+ SetEvent( handle->condition );
+ else
+ stopStream();
+ return;
+ }
+
+ // Invoke user callback to get fresh output data UNLESS we are
+ // draining stream.
+ if ( handle->drainCounter == 0 ) {
+ RtAudioCallback callback = (RtAudioCallback) info->callback;
+ double streamTime = getStreamTime();
+ RtAudioStreamStatus status = 0;
+ if ( stream_.mode != INPUT && handle->xrun[0] == true ) {
+ status |= RTAUDIO_OUTPUT_UNDERFLOW;
+ handle->xrun[0] = false;
+ }
+ if ( stream_.mode != OUTPUT && handle->xrun[1] == true ) {
+ status |= RTAUDIO_INPUT_OVERFLOW;
+ handle->xrun[1] = false;
+ }
+ int cbReturnValue = callback( stream_.userBuffer[0], stream_.userBuffer[1],
+ stream_.bufferSize, streamTime, status, info->userData );
+ if ( cbReturnValue == 2 ) {
+ stream_.state = STREAM_STOPPING;
+ handle->drainCounter = 2;
+ abortStream();
+ return;
+ }
+ else if ( cbReturnValue == 1 ) {
+ handle->drainCounter = 1;
+ handle->internalDrain = true;
+ }
+ }
+
+ HRESULT result;
+ DWORD currentWritePointer, safeWritePointer;
+ DWORD currentReadPointer, safeReadPointer;
+ UINT nextWritePointer;
+
+ LPVOID buffer1 = NULL;
+ LPVOID buffer2 = NULL;
+ DWORD bufferSize1 = 0;
+ DWORD bufferSize2 = 0;
+
+ char *buffer;
+ long bufferBytes;
+
+ MUTEX_LOCK( &stream_.mutex );
+ if ( stream_.state == STREAM_STOPPED ) {
+ MUTEX_UNLOCK( &stream_.mutex );
+ return;
+ }
+
+ if ( buffersRolling == false ) {
+ if ( stream_.mode == DUPLEX ) {
+ //assert( handle->dsBufferSize[0] == handle->dsBufferSize[1] );
+
+ // It takes a while for the devices to get rolling. As a result,
+ // there's no guarantee that the capture and write device pointers
+ // will move in lockstep. Wait here for both devices to start
+ // rolling, and then set our buffer pointers accordingly.
+ // e.g. Crystal Drivers: the capture buffer starts up 5700 to 9600
+ // bytes later than the write buffer.
+
+ // Stub: a serious risk of having a pre-emptive scheduling round
+ // take place between the two GetCurrentPosition calls... but I'm
+ // really not sure how to solve the problem. Temporarily boost to
+ // Realtime priority, maybe; but I'm not sure what priority the
+ // DirectSound service threads run at. We *should* be roughly
+ // within a ms or so of correct.
+
+ LPDIRECTSOUNDBUFFER dsWriteBuffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
+ LPDIRECTSOUNDCAPTUREBUFFER dsCaptureBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1];
+
+ DWORD startSafeWritePointer, startSafeReadPointer;
+
+ result = dsWriteBuffer->GetCurrentPosition( NULL, &startSafeWritePointer );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current write position!";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+ result = dsCaptureBuffer->GetCurrentPosition( NULL, &startSafeReadPointer );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current read position!";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+ while ( true ) {
+ result = dsWriteBuffer->GetCurrentPosition( NULL, &safeWritePointer );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current write position!";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+ result = dsCaptureBuffer->GetCurrentPosition( NULL, &safeReadPointer );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current read position!";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+ if ( safeWritePointer != startSafeWritePointer && safeReadPointer != startSafeReadPointer ) break;
+ Sleep( 1 );
+ }
+
+ //assert( handle->dsBufferSize[0] == handle->dsBufferSize[1] );
+
+ handle->bufferPointer[0] = safeWritePointer + handle->dsPointerLeadTime[0];
+ if ( handle->bufferPointer[0] >= handle->dsBufferSize[0] ) handle->bufferPointer[0] -= handle->dsBufferSize[0];
+ handle->bufferPointer[1] = safeReadPointer;
+ }
+ else if ( stream_.mode == OUTPUT ) {
+
+ // Set the proper nextWritePosition after initial startup.
+ LPDIRECTSOUNDBUFFER dsWriteBuffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
+ result = dsWriteBuffer->GetCurrentPosition( ¤tWritePointer, &safeWritePointer );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current write position!";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+ handle->bufferPointer[0] = safeWritePointer + handle->dsPointerLeadTime[0];
+ if ( handle->bufferPointer[0] >= handle->dsBufferSize[0] ) handle->bufferPointer[0] -= handle->dsBufferSize[0];
+ }
+
+ buffersRolling = true;
+ }
+
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+
+ LPDIRECTSOUNDBUFFER dsBuffer = (LPDIRECTSOUNDBUFFER) handle->buffer[0];
+
+ if ( handle->drainCounter > 1 ) { // write zeros to the output stream
+ bufferBytes = stream_.bufferSize * stream_.nUserChannels[0];
+ bufferBytes *= formatBytes( stream_.userFormat );
+ memset( stream_.userBuffer[0], 0, bufferBytes );
+ }
+
+ // Setup parameters and do buffer conversion if necessary.
+ if ( stream_.doConvertBuffer[0] ) {
+ buffer = stream_.deviceBuffer;
+ convertBuffer( buffer, stream_.userBuffer[0], stream_.convertInfo[0] );
+ bufferBytes = stream_.bufferSize * stream_.nDeviceChannels[0];
+ bufferBytes *= formatBytes( stream_.deviceFormat[0] );
+ }
+ else {
+ buffer = stream_.userBuffer[0];
+ bufferBytes = stream_.bufferSize * stream_.nUserChannels[0];
+ bufferBytes *= formatBytes( stream_.userFormat );
+ }
+
+ // No byte swapping necessary in DirectSound implementation.
+
+ // Ahhh ... windoze. 16-bit data is signed but 8-bit data is
+ // unsigned. So, we need to convert our signed 8-bit data here to
+ // unsigned.
+ if ( stream_.deviceFormat[0] == RTAUDIO_SINT8 )
+ for ( int i=0; i<bufferBytes; i++ ) buffer[i] = (unsigned char) ( buffer[i] + 128 );
+
+ DWORD dsBufferSize = handle->dsBufferSize[0];
+ nextWritePointer = handle->bufferPointer[0];
+
+ DWORD endWrite, leadPointer;
+ while ( true ) {
+ // Find out where the read and "safe write" pointers are.
+ result = dsBuffer->GetCurrentPosition( ¤tWritePointer, &safeWritePointer );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current write position!";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+
+ // We will copy our output buffer into the region between
+ // safeWritePointer and leadPointer. If leadPointer is not
+ // beyond the next endWrite position, wait until it is.
+ leadPointer = safeWritePointer + handle->dsPointerLeadTime[0];
+ //std::cout << "safeWritePointer = " << safeWritePointer << ", leadPointer = " << leadPointer << ", nextWritePointer = " << nextWritePointer << std::endl;
+ if ( leadPointer > dsBufferSize ) leadPointer -= dsBufferSize;
+ if ( leadPointer < nextWritePointer ) leadPointer += dsBufferSize; // unwrap offset
+ endWrite = nextWritePointer + bufferBytes;
+
+ // Check whether the entire write region is behind the play pointer.
+ if ( leadPointer >= endWrite ) break;
+
+ // If we are here, then we must wait until the leadPointer advances
+ // beyond the end of our next write region. We use the
+ // Sleep() function to suspend operation until that happens.
+ double millis = ( endWrite - leadPointer ) * 1000.0;
+ millis /= ( formatBytes( stream_.deviceFormat[0]) * stream_.nDeviceChannels[0] * stream_.sampleRate);
+ if ( millis < 1.0 ) millis = 1.0;
+ Sleep( (DWORD) millis );
+ }
+
+ if ( dsPointerBetween( nextWritePointer, safeWritePointer, currentWritePointer, dsBufferSize )
+ || dsPointerBetween( endWrite, safeWritePointer, currentWritePointer, dsBufferSize ) ) {
+ // We've strayed into the forbidden zone ... resync the read pointer.
+ handle->xrun[0] = true;
+ nextWritePointer = safeWritePointer + handle->dsPointerLeadTime[0] - bufferBytes;
+ if ( nextWritePointer >= dsBufferSize ) nextWritePointer -= dsBufferSize;
+ handle->bufferPointer[0] = nextWritePointer;
+ endWrite = nextWritePointer + bufferBytes;
+ }
+
+ // Lock free space in the buffer
+ result = dsBuffer->Lock( nextWritePointer, bufferBytes, &buffer1,
+ &bufferSize1, &buffer2, &bufferSize2, 0 );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") locking buffer during playback!";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+
+ // Copy our buffer into the DS buffer
+ CopyMemory( buffer1, buffer, bufferSize1 );
+ if ( buffer2 != NULL ) CopyMemory( buffer2, buffer+bufferSize1, bufferSize2 );
+
+ // Update our buffer offset and unlock sound buffer
+ dsBuffer->Unlock( buffer1, bufferSize1, buffer2, bufferSize2 );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") unlocking buffer during playback!";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+ nextWritePointer = ( nextWritePointer + bufferSize1 + bufferSize2 ) % dsBufferSize;
+ handle->bufferPointer[0] = nextWritePointer;
+ }
+
+ // Don't bother draining input
+ if ( handle->drainCounter ) {
+ handle->drainCounter++;
+ goto unlock;
+ }
+
+ if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
+
+ // Setup parameters.
+ if ( stream_.doConvertBuffer[1] ) {
+ buffer = stream_.deviceBuffer;
+ bufferBytes = stream_.bufferSize * stream_.nDeviceChannels[1];
+ bufferBytes *= formatBytes( stream_.deviceFormat[1] );
+ }
+ else {
+ buffer = stream_.userBuffer[1];
+ bufferBytes = stream_.bufferSize * stream_.nUserChannels[1];
+ bufferBytes *= formatBytes( stream_.userFormat );
+ }
+
+ LPDIRECTSOUNDCAPTUREBUFFER dsBuffer = (LPDIRECTSOUNDCAPTUREBUFFER) handle->buffer[1];
+ long nextReadPointer = handle->bufferPointer[1];
+ DWORD dsBufferSize = handle->dsBufferSize[1];
+
+ // Find out where the write and "safe read" pointers are.
+ result = dsBuffer->GetCurrentPosition( ¤tReadPointer, &safeReadPointer );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current read position!";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+
+ if ( safeReadPointer < (DWORD)nextReadPointer ) safeReadPointer += dsBufferSize; // unwrap offset
+ DWORD endRead = nextReadPointer + bufferBytes;
+
+ // Handling depends on whether we are INPUT or DUPLEX.
+ // If we're in INPUT mode then waiting is a good thing. If we're in DUPLEX mode,
+ // then a wait here will drag the write pointers into the forbidden zone.
+ //
+ // In DUPLEX mode, rather than wait, we will back off the read pointer until
+ // it's in a safe position. This causes dropouts, but it seems to be the only
+ // practical way to sync up the read and write pointers reliably, given the
+ // the very complex relationship between phase and increment of the read and write
+ // pointers.
+ //
+ // In order to minimize audible dropouts in DUPLEX mode, we will
+ // provide a pre-roll period of 0.5 seconds in which we return
+ // zeros from the read buffer while the pointers sync up.
+
+ if ( stream_.mode == DUPLEX ) {
+ if ( safeReadPointer < endRead ) {
+ if ( duplexPrerollBytes <= 0 ) {
+ // Pre-roll time over. Be more agressive.
+ int adjustment = endRead-safeReadPointer;
+
+ handle->xrun[1] = true;
+ // Two cases:
+ // - large adjustments: we've probably run out of CPU cycles, so just resync exactly,
+ // and perform fine adjustments later.
+ // - small adjustments: back off by twice as much.
+ if ( adjustment >= 2*bufferBytes )
+ nextReadPointer = safeReadPointer-2*bufferBytes;
+ else
+ nextReadPointer = safeReadPointer-bufferBytes-adjustment;
+
+ if ( nextReadPointer < 0 ) nextReadPointer += dsBufferSize;
+
+ }
+ else {
+ // In pre=roll time. Just do it.
+ nextReadPointer = safeReadPointer - bufferBytes;
+ while ( nextReadPointer < 0 ) nextReadPointer += dsBufferSize;
+ }
+ endRead = nextReadPointer + bufferBytes;
+ }
+ }
+ else { // mode == INPUT
+ while ( safeReadPointer < endRead && stream_.callbackInfo.isRunning ) {
+ // See comments for playback.
+ double millis = (endRead - safeReadPointer) * 1000.0;
+ millis /= ( formatBytes(stream_.deviceFormat[1]) * stream_.nDeviceChannels[1] * stream_.sampleRate);
+ if ( millis < 1.0 ) millis = 1.0;
+ Sleep( (DWORD) millis );
+
+ // Wake up and find out where we are now.
+ result = dsBuffer->GetCurrentPosition( ¤tReadPointer, &safeReadPointer );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") getting current read position!";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+
+ if ( safeReadPointer < (DWORD)nextReadPointer ) safeReadPointer += dsBufferSize; // unwrap offset
+ }
+ }
+
+ // Lock free space in the buffer
+ result = dsBuffer->Lock( nextReadPointer, bufferBytes, &buffer1,
+ &bufferSize1, &buffer2, &bufferSize2, 0 );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") locking capture buffer!";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+
+ if ( duplexPrerollBytes <= 0 ) {
+ // Copy our buffer into the DS buffer
+ CopyMemory( buffer, buffer1, bufferSize1 );
+ if ( buffer2 != NULL ) CopyMemory( buffer+bufferSize1, buffer2, bufferSize2 );
+ }
+ else {
+ memset( buffer, 0, bufferSize1 );
+ if ( buffer2 != NULL ) memset( buffer + bufferSize1, 0, bufferSize2 );
+ duplexPrerollBytes -= bufferSize1 + bufferSize2;
+ }
+
+ // Update our buffer offset and unlock sound buffer
+ nextReadPointer = ( nextReadPointer + bufferSize1 + bufferSize2 ) % dsBufferSize;
+ dsBuffer->Unlock( buffer1, bufferSize1, buffer2, bufferSize2 );
+ if ( FAILED( result ) ) {
+ errorStream_ << "RtApiDs::callbackEvent: error (" << getErrorString( result ) << ") unlocking capture buffer!";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+ handle->bufferPointer[1] = nextReadPointer;
+
+ // No byte swapping necessary in DirectSound implementation.
+
+ // If necessary, convert 8-bit data from unsigned to signed.
+ if ( stream_.deviceFormat[1] == RTAUDIO_SINT8 )
+ for ( int j=0; j<bufferBytes; j++ ) buffer[j] = (signed char) ( buffer[j] - 128 );
+
+ // Do buffer conversion if necessary.
+ if ( stream_.doConvertBuffer[1] )
+ convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] );
+ }
+
+ unlock:
+ MUTEX_UNLOCK( &stream_.mutex );
+ RtApi::tickStreamTime();
+}
+
+// Definitions for utility functions and callbacks
+// specific to the DirectSound implementation.
+
+static unsigned __stdcall callbackHandler( void *ptr )
+{
+ CallbackInfo *info = (CallbackInfo *) ptr;
+ RtApiDs *object = (RtApiDs *) info->object;
+ bool* isRunning = &info->isRunning;
+
+ while ( *isRunning == true ) {
+ object->callbackEvent();
+ }
+
+ _endthreadex( 0 );
+ return 0;
+}
+
+static BOOL CALLBACK deviceQueryCallback( LPGUID lpguid,
+ LPCTSTR description,
+ LPCTSTR /*module*/,
+ LPVOID lpContext )
+{
+ struct DsProbeData& probeInfo = *(struct DsProbeData*) lpContext;
+ std::vector<struct DsDevice>& dsDevices = *probeInfo.dsDevices;
+
+ HRESULT hr;
+ bool validDevice = false;
+ if ( probeInfo.isInput == true ) {
+ DSCCAPS caps;
+ LPDIRECTSOUNDCAPTURE object;
+
+ hr = DirectSoundCaptureCreate( lpguid, &object, NULL );
+ if ( hr != DS_OK ) return TRUE;
+
+ caps.dwSize = sizeof(caps);
+ hr = object->GetCaps( &caps );
+ if ( hr == DS_OK ) {
+ if ( caps.dwChannels > 0 && caps.dwFormats > 0 )
+ validDevice = true;
+ }
+ object->Release();
+ }
+ else {
+ DSCAPS caps;
+ LPDIRECTSOUND object;
+ hr = DirectSoundCreate( lpguid, &object, NULL );
+ if ( hr != DS_OK ) return TRUE;
+
+ caps.dwSize = sizeof(caps);
+ hr = object->GetCaps( &caps );
+ if ( hr == DS_OK ) {
+ if ( caps.dwFlags & DSCAPS_PRIMARYMONO || caps.dwFlags & DSCAPS_PRIMARYSTEREO )
+ validDevice = true;
+ }
+ object->Release();
+ }
+
+ // If good device, then save its name and guid.
+ std::string name = convertCharPointerToStdString( description );
+ //if ( name == "Primary Sound Driver" || name == "Primary Sound Capture Driver" )
+ if ( lpguid == NULL )
+ name = "Default Device";
+ if ( validDevice ) {
+ for ( unsigned int i=0; i<dsDevices.size(); i++ ) {
+ if ( dsDevices[i].name == name ) {
+ dsDevices[i].found = true;
+ if ( probeInfo.isInput ) {
+ dsDevices[i].id[1] = lpguid;
+ dsDevices[i].validId[1] = true;
+ }
+ else {
+ dsDevices[i].id[0] = lpguid;
+ dsDevices[i].validId[0] = true;
+ }
+ return TRUE;
+ }
+ }
+
+ DsDevice device;
+ device.name = name;
+ device.found = true;
+ if ( probeInfo.isInput ) {
+ device.id[1] = lpguid;
+ device.validId[1] = true;
+ }
+ else {
+ device.id[0] = lpguid;
+ device.validId[0] = true;
+ }
+ dsDevices.push_back( device );
+ }
+
+ return TRUE;
+}
+
+static const char* getErrorString( int code )
+{
+ switch ( code ) {
+
+ case DSERR_ALLOCATED:
+ return "Already allocated";
+
+ case DSERR_CONTROLUNAVAIL:
+ return "Control unavailable";
+
+ case DSERR_INVALIDPARAM:
+ return "Invalid parameter";
+
+ case DSERR_INVALIDCALL:
+ return "Invalid call";
+
+ case DSERR_GENERIC:
+ return "Generic error";
+
+ case DSERR_PRIOLEVELNEEDED:
+ return "Priority level needed";
+
+ case DSERR_OUTOFMEMORY:
+ return "Out of memory";
+
+ case DSERR_BADFORMAT:
+ return "The sample rate or the channel format is not supported";
+
+ case DSERR_UNSUPPORTED:
+ return "Not supported";
+
+ case DSERR_NODRIVER:
+ return "No driver";
+
+ case DSERR_ALREADYINITIALIZED:
+ return "Already initialized";
+
+ case DSERR_NOAGGREGATION:
+ return "No aggregation";
+
+ case DSERR_BUFFERLOST:
+ return "Buffer lost";
+
+ case DSERR_OTHERAPPHASPRIO:
+ return "Another application already has priority";
+
+ case DSERR_UNINITIALIZED:
+ return "Uninitialized";
+
+ default:
+ return "DirectSound unknown error";
+ }
+}
+//******************** End of __WINDOWS_DS__ *********************//
+#endif
+
+
+#if defined(__LINUX_ALSA__)
+
+#include <alsa/asoundlib.h>
+#include <unistd.h>
+
+ // A structure to hold various information related to the ALSA API
+ // implementation.
+struct AlsaHandle {
+ snd_pcm_t *handles[2];
+ bool synchronized;
+ bool xrun[2];
+ pthread_cond_t runnable_cv;
+ bool runnable;
+
+ AlsaHandle()
+ :synchronized(false), runnable(false) { xrun[0] = false; xrun[1] = false; }
+};
+
+static void *alsaCallbackHandler( void * ptr );
+
+RtApiAlsa :: RtApiAlsa()
+{
+ // Nothing to do here.
+}
+
+RtApiAlsa :: ~RtApiAlsa()
+{
+ if ( stream_.state != STREAM_CLOSED ) closeStream();
+}
+
+unsigned int RtApiAlsa :: getDeviceCount( void )
+{
+ unsigned nDevices = 0;
+ int result, subdevice, card;
+ char name[64];
+ snd_ctl_t *handle = 0;
+
+ // Count cards and devices
+ card = -1;
+ snd_card_next( &card );
+ while ( card >= 0 ) {
+ sprintf( name, "hw:%d", card );
+ result = snd_ctl_open( &handle, name, 0 );
+ if ( result < 0 ) {
+ handle = 0;
+ errorStream_ << "RtApiAlsa::getDeviceCount: control open, card = " << card << ", " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ goto nextcard;
+ }
+ subdevice = -1;
+ while( 1 ) {
+ result = snd_ctl_pcm_next_device( handle, &subdevice );
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::getDeviceCount: control next device, card = " << card << ", " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ break;
+ }
+ if ( subdevice < 0 )
+ break;
+ nDevices++;
+ }
+ nextcard:
+ if ( handle )
+ snd_ctl_close( handle );
+ snd_card_next( &card );
+ }
+
+ result = snd_ctl_open( &handle, "default", 0 );
+ if (result == 0) {
+ nDevices++;
+ snd_ctl_close( handle );
+ }
+
+ return nDevices;
+}
+
+RtAudio::DeviceInfo RtApiAlsa :: getDeviceInfo( unsigned int device )
+{
+ RtAudio::DeviceInfo info;
+ info.probed = false;
+
+ unsigned nDevices = 0;
+ int result, subdevice, card;
+ char name[64];
+ snd_ctl_t *chandle = 0;
+
+ // Count cards and devices
+ card = -1;
+ subdevice = -1;
+ snd_card_next( &card );
+ while ( card >= 0 ) {
+ sprintf( name, "hw:%d", card );
+ result = snd_ctl_open( &chandle, name, SND_CTL_NONBLOCK );
+ if ( result < 0 ) {
+ chandle = 0;
+ errorStream_ << "RtApiAlsa::getDeviceInfo: control open, card = " << card << ", " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ goto nextcard;
+ }
+ subdevice = -1;
+ while( 1 ) {
+ result = snd_ctl_pcm_next_device( chandle, &subdevice );
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::getDeviceInfo: control next device, card = " << card << ", " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ break;
+ }
+ if ( subdevice < 0 ) break;
+ if ( nDevices == device ) {
+ sprintf( name, "hw:%d,%d", card, subdevice );
+ goto foundDevice;
+ }
+ nDevices++;
+ }
+ nextcard:
+ if ( chandle )
+ snd_ctl_close( chandle );
+ snd_card_next( &card );
+ }
+
+ result = snd_ctl_open( &chandle, "default", SND_CTL_NONBLOCK );
+ if ( result == 0 ) {
+ if ( nDevices == device ) {
+ strcpy( name, "default" );
+ goto foundDevice;
+ }
+ nDevices++;
+ }
+
+ if ( nDevices == 0 ) {
+ errorText_ = "RtApiAlsa::getDeviceInfo: no devices found!";
+ error( RtAudioError::INVALID_USE );
+ return info;
+ }
+
+ if ( device >= nDevices ) {
+ errorText_ = "RtApiAlsa::getDeviceInfo: device ID is invalid!";
+ error( RtAudioError::INVALID_USE );
+ return info;
+ }
+
+ foundDevice:
+
+ // If a stream is already open, we cannot probe the stream devices.
+ // Thus, use the saved results.
+ if ( stream_.state != STREAM_CLOSED &&
+ ( stream_.device[0] == device || stream_.device[1] == device ) ) {
+ snd_ctl_close( chandle );
+ if ( device >= devices_.size() ) {
+ errorText_ = "RtApiAlsa::getDeviceInfo: device ID was not present before stream was opened.";
+ error( RtAudioError::WARNING );
+ return info;
+ }
+ return devices_[ device ];
+ }
+
+ int openMode = SND_PCM_ASYNC;
+ snd_pcm_stream_t stream;
+ snd_pcm_info_t *pcminfo;
+ snd_pcm_info_alloca( &pcminfo );
+ snd_pcm_t *phandle;
+ snd_pcm_hw_params_t *params;
+ snd_pcm_hw_params_alloca( ¶ms );
+
+ // First try for playback unless default device (which has subdev -1)
+ stream = SND_PCM_STREAM_PLAYBACK;
+ snd_pcm_info_set_stream( pcminfo, stream );
+ if ( subdevice != -1 ) {
+ snd_pcm_info_set_device( pcminfo, subdevice );
+ snd_pcm_info_set_subdevice( pcminfo, 0 );
+
+ result = snd_ctl_pcm_info( chandle, pcminfo );
+ if ( result < 0 ) {
+ // Device probably doesn't support playback.
+ goto captureProbe;
+ }
+ }
+
+ result = snd_pcm_open( &phandle, name, stream, openMode | SND_PCM_NONBLOCK );
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_open error for device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ goto captureProbe;
+ }
+
+ // The device is open ... fill the parameter structure.
+ result = snd_pcm_hw_params_any( phandle, params );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_hw_params error for device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ goto captureProbe;
+ }
+
+ // Get output channel information.
+ unsigned int value;
+ result = snd_pcm_hw_params_get_channels_max( params, &value );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::getDeviceInfo: error getting device (" << name << ") output channels, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ goto captureProbe;
+ }
+ info.outputChannels = value;
+ snd_pcm_close( phandle );
+
+ captureProbe:
+ stream = SND_PCM_STREAM_CAPTURE;
+ snd_pcm_info_set_stream( pcminfo, stream );
+
+ // Now try for capture unless default device (with subdev = -1)
+ if ( subdevice != -1 ) {
+ result = snd_ctl_pcm_info( chandle, pcminfo );
+ snd_ctl_close( chandle );
+ if ( result < 0 ) {
+ // Device probably doesn't support capture.
+ if ( info.outputChannels == 0 ) return info;
+ goto probeParameters;
+ }
+ }
+ else
+ snd_ctl_close( chandle );
+
+ result = snd_pcm_open( &phandle, name, stream, openMode | SND_PCM_NONBLOCK);
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_open error for device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ if ( info.outputChannels == 0 ) return info;
+ goto probeParameters;
+ }
+
+ // The device is open ... fill the parameter structure.
+ result = snd_pcm_hw_params_any( phandle, params );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_hw_params error for device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ if ( info.outputChannels == 0 ) return info;
+ goto probeParameters;
+ }
+
+ result = snd_pcm_hw_params_get_channels_max( params, &value );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::getDeviceInfo: error getting device (" << name << ") input channels, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ if ( info.outputChannels == 0 ) return info;
+ goto probeParameters;
+ }
+ info.inputChannels = value;
+ snd_pcm_close( phandle );
+
+ // If device opens for both playback and capture, we determine the channels.
+ if ( info.outputChannels > 0 && info.inputChannels > 0 )
+ info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels;
+
+ // ALSA doesn't provide default devices so we'll use the first available one.
+ if ( device == 0 && info.outputChannels > 0 )
+ info.isDefaultOutput = true;
+ if ( device == 0 && info.inputChannels > 0 )
+ info.isDefaultInput = true;
+
+ probeParameters:
+ // At this point, we just need to figure out the supported data
+ // formats and sample rates. We'll proceed by opening the device in
+ // the direction with the maximum number of channels, or playback if
+ // they are equal. This might limit our sample rate options, but so
+ // be it.
+
+ if ( info.outputChannels >= info.inputChannels )
+ stream = SND_PCM_STREAM_PLAYBACK;
+ else
+ stream = SND_PCM_STREAM_CAPTURE;
+ snd_pcm_info_set_stream( pcminfo, stream );
+
+ result = snd_pcm_open( &phandle, name, stream, openMode | SND_PCM_NONBLOCK);
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_open error for device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // The device is open ... fill the parameter structure.
+ result = snd_pcm_hw_params_any( phandle, params );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::getDeviceInfo: snd_pcm_hw_params error for device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // Test our discrete set of sample rate values.
+ info.sampleRates.clear();
+ for ( unsigned int i=0; i<MAX_SAMPLE_RATES; i++ ) {
+ if ( snd_pcm_hw_params_test_rate( phandle, params, SAMPLE_RATES[i], 0 ) == 0 ) {
+ info.sampleRates.push_back( SAMPLE_RATES[i] );
+
+ if ( !info.preferredSampleRate || ( SAMPLE_RATES[i] <= 48000 && SAMPLE_RATES[i] > info.preferredSampleRate ) )
+ info.preferredSampleRate = SAMPLE_RATES[i];
+ }
+ }
+ if ( info.sampleRates.size() == 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::getDeviceInfo: no supported sample rates found for device (" << name << ").";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // Probe the supported data formats ... we don't care about endian-ness just yet
+ snd_pcm_format_t format;
+ info.nativeFormats = 0;
+ format = SND_PCM_FORMAT_S8;
+ if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 )
+ info.nativeFormats |= RTAUDIO_SINT8;
+ format = SND_PCM_FORMAT_S16;
+ if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 )
+ info.nativeFormats |= RTAUDIO_SINT16;
+ format = SND_PCM_FORMAT_S24;
+ if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 )
+ info.nativeFormats |= RTAUDIO_SINT24;
+ format = SND_PCM_FORMAT_S32;
+ if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 )
+ info.nativeFormats |= RTAUDIO_SINT32;
+ format = SND_PCM_FORMAT_FLOAT;
+ if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 )
+ info.nativeFormats |= RTAUDIO_FLOAT32;
+ format = SND_PCM_FORMAT_FLOAT64;
+ if ( snd_pcm_hw_params_test_format( phandle, params, format ) == 0 )
+ info.nativeFormats |= RTAUDIO_FLOAT64;
+
+ // Check that we have at least one supported format
+ if ( info.nativeFormats == 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::getDeviceInfo: pcm device (" << name << ") data format not supported by RtAudio.";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // Get the device name
+ char *cardname;
+ result = snd_card_get_name( card, &cardname );
+ if ( result >= 0 ) {
+ sprintf( name, "hw:%s,%d", cardname, subdevice );
+ free( cardname );
+ }
+ info.name = name;
+
+ // That's all ... close the device and return
+ snd_pcm_close( phandle );
+ info.probed = true;
+ return info;
+}
+
+void RtApiAlsa :: saveDeviceInfo( void )
+{
+ devices_.clear();
+
+ unsigned int nDevices = getDeviceCount();
+ devices_.resize( nDevices );
+ for ( unsigned int i=0; i<nDevices; i++ )
+ devices_[i] = getDeviceInfo( i );
+}
+
+bool RtApiAlsa :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options )
+
+{
+#if defined(__RTAUDIO_DEBUG__)
+ snd_output_t *out;
+ snd_output_stdio_attach(&out, stderr, 0);
+#endif
+
+ // I'm not using the "plug" interface ... too much inconsistent behavior.
+
+ unsigned nDevices = 0;
+ int result, subdevice, card;
+ char name[64];
+ snd_ctl_t *chandle;
+
+ if ( options && options->flags & RTAUDIO_ALSA_USE_DEFAULT )
+ snprintf(name, sizeof(name), "%s", "default");
+ else {
+ // Count cards and devices
+ card = -1;
+ snd_card_next( &card );
+ while ( card >= 0 ) {
+ sprintf( name, "hw:%d", card );
+ result = snd_ctl_open( &chandle, name, SND_CTL_NONBLOCK );
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: control open, card = " << card << ", " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ subdevice = -1;
+ while( 1 ) {
+ result = snd_ctl_pcm_next_device( chandle, &subdevice );
+ if ( result < 0 ) break;
+ if ( subdevice < 0 ) break;
+ if ( nDevices == device ) {
+ sprintf( name, "hw:%d,%d", card, subdevice );
+ snd_ctl_close( chandle );
+ goto foundDevice;
+ }
+ nDevices++;
+ }
+ snd_ctl_close( chandle );
+ snd_card_next( &card );
+ }
+
+ result = snd_ctl_open( &chandle, "default", SND_CTL_NONBLOCK );
+ if ( result == 0 ) {
+ if ( nDevices == device ) {
+ strcpy( name, "default" );
+ snd_ctl_close( chandle );
+ goto foundDevice;
+ }
+ nDevices++;
+ }
+ snd_ctl_close( chandle );
+
+ if ( nDevices == 0 ) {
+ // This should not happen because a check is made before this function is called.
+ errorText_ = "RtApiAlsa::probeDeviceOpen: no devices found!";
+ return FAILURE;
+ }
+
+ if ( device >= nDevices ) {
+ // This should not happen because a check is made before this function is called.
+ errorText_ = "RtApiAlsa::probeDeviceOpen: device ID is invalid!";
+ return FAILURE;
+ }
+ }
+
+ foundDevice:
+
+ // The getDeviceInfo() function will not work for a device that is
+ // already open. Thus, we'll probe the system before opening a
+ // stream and save the results for use by getDeviceInfo().
+ if ( mode == OUTPUT || ( mode == INPUT && stream_.mode != OUTPUT ) ) // only do once
+ this->saveDeviceInfo();
+
+ snd_pcm_stream_t stream;
+ if ( mode == OUTPUT )
+ stream = SND_PCM_STREAM_PLAYBACK;
+ else
+ stream = SND_PCM_STREAM_CAPTURE;
+
+ snd_pcm_t *phandle;
+ int openMode = SND_PCM_ASYNC;
+ result = snd_pcm_open( &phandle, name, stream, openMode );
+ if ( result < 0 ) {
+ if ( mode == OUTPUT )
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: pcm device (" << name << ") won't open for output.";
+ else
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: pcm device (" << name << ") won't open for input.";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Fill the parameter structure.
+ snd_pcm_hw_params_t *hw_params;
+ snd_pcm_hw_params_alloca( &hw_params );
+ result = snd_pcm_hw_params_any( phandle, hw_params );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: error getting pcm device (" << name << ") parameters, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+#if defined(__RTAUDIO_DEBUG__)
+ fprintf( stderr, "\nRtApiAlsa: dump hardware params just after device open:\n\n" );
+ snd_pcm_hw_params_dump( hw_params, out );
+#endif
+
+ // Set access ... check user preference.
+ if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) {
+ stream_.userInterleaved = false;
+ result = snd_pcm_hw_params_set_access( phandle, hw_params, SND_PCM_ACCESS_RW_NONINTERLEAVED );
+ if ( result < 0 ) {
+ result = snd_pcm_hw_params_set_access( phandle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED );
+ stream_.deviceInterleaved[mode] = true;
+ }
+ else
+ stream_.deviceInterleaved[mode] = false;
+ }
+ else {
+ stream_.userInterleaved = true;
+ result = snd_pcm_hw_params_set_access( phandle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED );
+ if ( result < 0 ) {
+ result = snd_pcm_hw_params_set_access( phandle, hw_params, SND_PCM_ACCESS_RW_NONINTERLEAVED );
+ stream_.deviceInterleaved[mode] = false;
+ }
+ else
+ stream_.deviceInterleaved[mode] = true;
+ }
+
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting pcm device (" << name << ") access, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Determine how to set the device format.
+ stream_.userFormat = format;
+ snd_pcm_format_t deviceFormat = SND_PCM_FORMAT_UNKNOWN;
+
+ if ( format == RTAUDIO_SINT8 )
+ deviceFormat = SND_PCM_FORMAT_S8;
+ else if ( format == RTAUDIO_SINT16 )
+ deviceFormat = SND_PCM_FORMAT_S16;
+ else if ( format == RTAUDIO_SINT24 )
+ deviceFormat = SND_PCM_FORMAT_S24;
+ else if ( format == RTAUDIO_SINT32 )
+ deviceFormat = SND_PCM_FORMAT_S32;
+ else if ( format == RTAUDIO_FLOAT32 )
+ deviceFormat = SND_PCM_FORMAT_FLOAT;
+ else if ( format == RTAUDIO_FLOAT64 )
+ deviceFormat = SND_PCM_FORMAT_FLOAT64;
+
+ if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat) == 0) {
+ stream_.deviceFormat[mode] = format;
+ goto setFormat;
+ }
+
+ // The user requested format is not natively supported by the device.
+ deviceFormat = SND_PCM_FORMAT_FLOAT64;
+ if ( snd_pcm_hw_params_test_format( phandle, hw_params, deviceFormat ) == 0 ) {
+ stream_.deviceFormat[mode] = RTAUDIO_FLOAT64;
+ goto setFormat;
+ }
+
+ deviceFormat = SND_PCM_FORMAT_FLOAT;
+ if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) {
+ stream_.deviceFormat[mode] = RTAUDIO_FLOAT32;
+ goto setFormat;
+ }
+
+ deviceFormat = SND_PCM_FORMAT_S32;
+ if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) {
+ stream_.deviceFormat[mode] = RTAUDIO_SINT32;
+ goto setFormat;
+ }
+
+ deviceFormat = SND_PCM_FORMAT_S24;
+ if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) {
+ stream_.deviceFormat[mode] = RTAUDIO_SINT24;
+ goto setFormat;
+ }
+
+ deviceFormat = SND_PCM_FORMAT_S16;
+ if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) {
+ stream_.deviceFormat[mode] = RTAUDIO_SINT16;
+ goto setFormat;
+ }
+
+ deviceFormat = SND_PCM_FORMAT_S8;
+ if ( snd_pcm_hw_params_test_format(phandle, hw_params, deviceFormat ) == 0 ) {
+ stream_.deviceFormat[mode] = RTAUDIO_SINT8;
+ goto setFormat;
+ }
+
+ // If we get here, no supported format was found.
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: pcm device " << device << " data format not supported by RtAudio.";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+
+ setFormat:
+ result = snd_pcm_hw_params_set_format( phandle, hw_params, deviceFormat );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting pcm device (" << name << ") data format, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Determine whether byte-swaping is necessary.
+ stream_.doByteSwap[mode] = false;
+ if ( deviceFormat != SND_PCM_FORMAT_S8 ) {
+ result = snd_pcm_format_cpu_endian( deviceFormat );
+ if ( result == 0 )
+ stream_.doByteSwap[mode] = true;
+ else if (result < 0) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: error getting pcm device (" << name << ") endian-ness, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ }
+
+ // Set the sample rate.
+ result = snd_pcm_hw_params_set_rate_near( phandle, hw_params, (unsigned int*) &sampleRate, 0 );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting sample rate on device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Determine the number of channels for this device. We support a possible
+ // minimum device channel number > than the value requested by the user.
+ stream_.nUserChannels[mode] = channels;
+ unsigned int value;
+ result = snd_pcm_hw_params_get_channels_max( hw_params, &value );
+ unsigned int deviceChannels = value;
+ if ( result < 0 || deviceChannels < channels + firstChannel ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: requested channel parameters not supported by device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ result = snd_pcm_hw_params_get_channels_min( hw_params, &value );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: error getting minimum channels for device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ deviceChannels = value;
+ if ( deviceChannels < channels + firstChannel ) deviceChannels = channels + firstChannel;
+ stream_.nDeviceChannels[mode] = deviceChannels;
+
+ // Set the device channels.
+ result = snd_pcm_hw_params_set_channels( phandle, hw_params, deviceChannels );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting channels for device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Set the buffer (or period) size.
+ int dir = 0;
+ snd_pcm_uframes_t periodSize = *bufferSize;
+ result = snd_pcm_hw_params_set_period_size_near( phandle, hw_params, &periodSize, &dir );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting period size for device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ *bufferSize = periodSize;
+
+ // Set the buffer number, which in ALSA is referred to as the "period".
+ unsigned int periods = 0;
+ if ( options && options->flags & RTAUDIO_MINIMIZE_LATENCY ) periods = 2;
+ if ( options && options->numberOfBuffers > 0 ) periods = options->numberOfBuffers;
+ if ( periods < 2 ) periods = 4; // a fairly safe default value
+ result = snd_pcm_hw_params_set_periods_near( phandle, hw_params, &periods, &dir );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: error setting periods for device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // If attempting to setup a duplex stream, the bufferSize parameter
+ // MUST be the same in both directions!
+ if ( stream_.mode == OUTPUT && mode == INPUT && *bufferSize != stream_.bufferSize ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: system error setting buffer size for duplex stream on device (" << name << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ stream_.bufferSize = *bufferSize;
+
+ // Install the hardware configuration
+ result = snd_pcm_hw_params( phandle, hw_params );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: error installing hardware configuration on device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+#if defined(__RTAUDIO_DEBUG__)
+ fprintf(stderr, "\nRtApiAlsa: dump hardware params after installation:\n\n");
+ snd_pcm_hw_params_dump( hw_params, out );
+#endif
+
+ // Set the software configuration to fill buffers with zeros and prevent device stopping on xruns.
+ snd_pcm_sw_params_t *sw_params = NULL;
+ snd_pcm_sw_params_alloca( &sw_params );
+ snd_pcm_sw_params_current( phandle, sw_params );
+ snd_pcm_sw_params_set_start_threshold( phandle, sw_params, *bufferSize );
+ snd_pcm_sw_params_set_stop_threshold( phandle, sw_params, ULONG_MAX );
+ snd_pcm_sw_params_set_silence_threshold( phandle, sw_params, 0 );
+
+ // The following two settings were suggested by Theo Veenker
+ //snd_pcm_sw_params_set_avail_min( phandle, sw_params, *bufferSize );
+ //snd_pcm_sw_params_set_xfer_align( phandle, sw_params, 1 );
+
+ // here are two options for a fix
+ //snd_pcm_sw_params_set_silence_size( phandle, sw_params, ULONG_MAX );
+ snd_pcm_uframes_t val;
+ snd_pcm_sw_params_get_boundary( sw_params, &val );
+ snd_pcm_sw_params_set_silence_size( phandle, sw_params, val );
+
+ result = snd_pcm_sw_params( phandle, sw_params );
+ if ( result < 0 ) {
+ snd_pcm_close( phandle );
+ errorStream_ << "RtApiAlsa::probeDeviceOpen: error installing software configuration on device (" << name << "), " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+#if defined(__RTAUDIO_DEBUG__)
+ fprintf(stderr, "\nRtApiAlsa: dump software params after installation:\n\n");
+ snd_pcm_sw_params_dump( sw_params, out );
+#endif
+
+ // Set flags for buffer conversion
+ stream_.doConvertBuffer[mode] = false;
+ if ( stream_.userFormat != stream_.deviceFormat[mode] )
+ stream_.doConvertBuffer[mode] = true;
+ if ( stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode] )
+ stream_.doConvertBuffer[mode] = true;
+ if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] &&
+ stream_.nUserChannels[mode] > 1 )
+ stream_.doConvertBuffer[mode] = true;
+
+ // Allocate the ApiHandle if necessary and then save.
+ AlsaHandle *apiInfo = 0;
+ if ( stream_.apiHandle == 0 ) {
+ try {
+ apiInfo = (AlsaHandle *) new AlsaHandle;
+ }
+ catch ( std::bad_alloc& ) {
+ errorText_ = "RtApiAlsa::probeDeviceOpen: error allocating AlsaHandle memory.";
+ goto error;
+ }
+
+ if ( pthread_cond_init( &apiInfo->runnable_cv, NULL ) ) {
+ errorText_ = "RtApiAlsa::probeDeviceOpen: error initializing pthread condition variable.";
+ goto error;
+ }
+
+ stream_.apiHandle = (void *) apiInfo;
+ apiInfo->handles[0] = 0;
+ apiInfo->handles[1] = 0;
+ }
+ else {
+ apiInfo = (AlsaHandle *) stream_.apiHandle;
+ }
+ apiInfo->handles[mode] = phandle;
+ phandle = 0;
+
+ // Allocate necessary internal buffers.
+ unsigned long bufferBytes;
+ bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
+ stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
+ if ( stream_.userBuffer[mode] == NULL ) {
+ errorText_ = "RtApiAlsa::probeDeviceOpen: error allocating user buffer memory.";
+ goto error;
+ }
+
+ if ( stream_.doConvertBuffer[mode] ) {
+
+ bool makeBuffer = true;
+ bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] );
+ if ( mode == INPUT ) {
+ if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) {
+ unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
+ if ( bufferBytes <= bytesOut ) makeBuffer = false;
+ }
+ }
+
+ if ( makeBuffer ) {
+ bufferBytes *= *bufferSize;
+ if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
+ stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
+ if ( stream_.deviceBuffer == NULL ) {
+ errorText_ = "RtApiAlsa::probeDeviceOpen: error allocating device buffer memory.";
+ goto error;
+ }
+ }
+ }
+
+ stream_.sampleRate = sampleRate;
+ stream_.nBuffers = periods;
+ stream_.device[mode] = device;
+ stream_.state = STREAM_STOPPED;
+
+ // Setup the buffer conversion information structure.
+ if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, firstChannel );
+
+ // Setup thread if necessary.
+ if ( stream_.mode == OUTPUT && mode == INPUT ) {
+ // We had already set up an output stream.
+ stream_.mode = DUPLEX;
+ // Link the streams if possible.
+ apiInfo->synchronized = false;
+ if ( snd_pcm_link( apiInfo->handles[0], apiInfo->handles[1] ) == 0 )
+ apiInfo->synchronized = true;
+ else {
+ errorText_ = "RtApiAlsa::probeDeviceOpen: unable to synchronize input and output devices.";
+ error( RtAudioError::WARNING );
+ }
+ }
+ else {
+ stream_.mode = mode;
+
+ // Setup callback thread.
+ stream_.callbackInfo.object = (void *) this;
+
+ // Set the thread attributes for joinable and realtime scheduling
+ // priority (optional). The higher priority will only take affect
+ // if the program is run as root or suid. Note, under Linux
+ // processes with CAP_SYS_NICE privilege, a user can change
+ // scheduling policy and priority (thus need not be root). See
+ // POSIX "capabilities".
+ pthread_attr_t attr;
+ pthread_attr_init( &attr );
+ pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
+#ifdef SCHED_RR // Undefined with some OSes (e.g. NetBSD 1.6.x with GNU Pthread)
+ if ( options && options->flags & RTAUDIO_SCHEDULE_REALTIME ) {
+ stream_.callbackInfo.doRealtime = true;
+ struct sched_param param;
+ int priority = options->priority;
+ int min = sched_get_priority_min( SCHED_RR );
+ int max = sched_get_priority_max( SCHED_RR );
+ if ( priority < min ) priority = min;
+ else if ( priority > max ) priority = max;
+ param.sched_priority = priority;
+
+ // Set the policy BEFORE the priority. Otherwise it fails.
+ pthread_attr_setschedpolicy(&attr, SCHED_RR);
+ pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);
+ // This is definitely required. Otherwise it fails.
+ pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
+ pthread_attr_setschedparam(&attr, ¶m);
+ }
+ else
+ pthread_attr_setschedpolicy( &attr, SCHED_OTHER );
+#else
+ pthread_attr_setschedpolicy( &attr, SCHED_OTHER );
+#endif
+
+ stream_.callbackInfo.isRunning = true;
+ result = pthread_create( &stream_.callbackInfo.thread, &attr, alsaCallbackHandler, &stream_.callbackInfo );
+ pthread_attr_destroy( &attr );
+ if ( result ) {
+ // Failed. Try instead with default attributes.
+ result = pthread_create( &stream_.callbackInfo.thread, NULL, alsaCallbackHandler, &stream_.callbackInfo );
+ if ( result ) {
+ stream_.callbackInfo.isRunning = false;
+ errorText_ = "RtApiAlsa::error creating callback thread!";
+ goto error;
+ }
+ }
+ }
+
+ return SUCCESS;
+
+ error:
+ if ( apiInfo ) {
+ pthread_cond_destroy( &apiInfo->runnable_cv );
+ if ( apiInfo->handles[0] ) snd_pcm_close( apiInfo->handles[0] );
+ if ( apiInfo->handles[1] ) snd_pcm_close( apiInfo->handles[1] );
+ delete apiInfo;
+ stream_.apiHandle = 0;
+ }
+
+ if ( phandle) snd_pcm_close( phandle );
+
+ for ( int i=0; i<2; i++ ) {
+ if ( stream_.userBuffer[i] ) {
+ free( stream_.userBuffer[i] );
+ stream_.userBuffer[i] = 0;
+ }
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+
+ stream_.state = STREAM_CLOSED;
+ return FAILURE;
+}
+
+void RtApiAlsa :: closeStream()
+{
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiAlsa::closeStream(): no open stream to close!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle;
+ stream_.callbackInfo.isRunning = false;
+ MUTEX_LOCK( &stream_.mutex );
+ if ( stream_.state == STREAM_STOPPED ) {
+ apiInfo->runnable = true;
+ pthread_cond_signal( &apiInfo->runnable_cv );
+ }
+ MUTEX_UNLOCK( &stream_.mutex );
+ pthread_join( stream_.callbackInfo.thread, NULL );
+
+ if ( stream_.state == STREAM_RUNNING ) {
+ stream_.state = STREAM_STOPPED;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX )
+ snd_pcm_drop( apiInfo->handles[0] );
+ if ( stream_.mode == INPUT || stream_.mode == DUPLEX )
+ snd_pcm_drop( apiInfo->handles[1] );
+ }
+
+ if ( apiInfo ) {
+ pthread_cond_destroy( &apiInfo->runnable_cv );
+ if ( apiInfo->handles[0] ) snd_pcm_close( apiInfo->handles[0] );
+ if ( apiInfo->handles[1] ) snd_pcm_close( apiInfo->handles[1] );
+ delete apiInfo;
+ stream_.apiHandle = 0;
+ }
+
+ for ( int i=0; i<2; i++ ) {
+ if ( stream_.userBuffer[i] ) {
+ free( stream_.userBuffer[i] );
+ stream_.userBuffer[i] = 0;
+ }
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+
+ stream_.mode = UNINITIALIZED;
+ stream_.state = STREAM_CLOSED;
+}
+
+void RtApiAlsa :: startStream()
+{
+ // This method calls snd_pcm_prepare if the device isn't already in that state.
+
+ verifyStream();
+ if ( stream_.state == STREAM_RUNNING ) {
+ errorText_ = "RtApiAlsa::startStream(): the stream is already running!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ MUTEX_LOCK( &stream_.mutex );
+
+ #if defined( HAVE_GETTIMEOFDAY )
+ gettimeofday( &stream_.lastTickTimestamp, NULL );
+ #endif
+
+ int result = 0;
+ snd_pcm_state_t state;
+ AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle;
+ snd_pcm_t **handle = (snd_pcm_t **) apiInfo->handles;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+ state = snd_pcm_state( handle[0] );
+ if ( state != SND_PCM_STATE_PREPARED ) {
+ result = snd_pcm_prepare( handle[0] );
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::startStream: error preparing output pcm device, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+ }
+
+ if ( ( stream_.mode == INPUT || stream_.mode == DUPLEX ) && !apiInfo->synchronized ) {
+ result = snd_pcm_drop(handle[1]); // fix to remove stale data received since device has been open
+ state = snd_pcm_state( handle[1] );
+ if ( state != SND_PCM_STATE_PREPARED ) {
+ result = snd_pcm_prepare( handle[1] );
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::startStream: error preparing input pcm device, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+ }
+
+ stream_.state = STREAM_RUNNING;
+
+ unlock:
+ apiInfo->runnable = true;
+ pthread_cond_signal( &apiInfo->runnable_cv );
+ MUTEX_UNLOCK( &stream_.mutex );
+
+ if ( result >= 0 ) return;
+ error( RtAudioError::SYSTEM_ERROR );
+}
+
+void RtApiAlsa :: stopStream()
+{
+ verifyStream();
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiAlsa::stopStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ stream_.state = STREAM_STOPPED;
+ MUTEX_LOCK( &stream_.mutex );
+
+ int result = 0;
+ AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle;
+ snd_pcm_t **handle = (snd_pcm_t **) apiInfo->handles;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+ if ( apiInfo->synchronized )
+ result = snd_pcm_drop( handle[0] );
+ else
+ result = snd_pcm_drain( handle[0] );
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::stopStream: error draining output pcm device, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+
+ if ( ( stream_.mode == INPUT || stream_.mode == DUPLEX ) && !apiInfo->synchronized ) {
+ result = snd_pcm_drop( handle[1] );
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::stopStream: error stopping input pcm device, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+
+ unlock:
+ apiInfo->runnable = false; // fixes high CPU usage when stopped
+ MUTEX_UNLOCK( &stream_.mutex );
+
+ if ( result >= 0 ) return;
+ error( RtAudioError::SYSTEM_ERROR );
+}
+
+void RtApiAlsa :: abortStream()
+{
+ verifyStream();
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiAlsa::abortStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ stream_.state = STREAM_STOPPED;
+ MUTEX_LOCK( &stream_.mutex );
+
+ int result = 0;
+ AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle;
+ snd_pcm_t **handle = (snd_pcm_t **) apiInfo->handles;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+ result = snd_pcm_drop( handle[0] );
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::abortStream: error aborting output pcm device, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+
+ if ( ( stream_.mode == INPUT || stream_.mode == DUPLEX ) && !apiInfo->synchronized ) {
+ result = snd_pcm_drop( handle[1] );
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::abortStream: error aborting input pcm device, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+
+ unlock:
+ apiInfo->runnable = false; // fixes high CPU usage when stopped
+ MUTEX_UNLOCK( &stream_.mutex );
+
+ if ( result >= 0 ) return;
+ error( RtAudioError::SYSTEM_ERROR );
+}
+
+void RtApiAlsa :: callbackEvent()
+{
+ AlsaHandle *apiInfo = (AlsaHandle *) stream_.apiHandle;
+ if ( stream_.state == STREAM_STOPPED ) {
+ MUTEX_LOCK( &stream_.mutex );
+ while ( !apiInfo->runnable )
+ pthread_cond_wait( &apiInfo->runnable_cv, &stream_.mutex );
+
+ if ( stream_.state != STREAM_RUNNING ) {
+ MUTEX_UNLOCK( &stream_.mutex );
+ return;
+ }
+ MUTEX_UNLOCK( &stream_.mutex );
+ }
+
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiAlsa::callbackEvent(): the stream is closed ... this shouldn't happen!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ int doStopStream = 0;
+ RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback;
+ double streamTime = getStreamTime();
+ RtAudioStreamStatus status = 0;
+ if ( stream_.mode != INPUT && apiInfo->xrun[0] == true ) {
+ status |= RTAUDIO_OUTPUT_UNDERFLOW;
+ apiInfo->xrun[0] = false;
+ }
+ if ( stream_.mode != OUTPUT && apiInfo->xrun[1] == true ) {
+ status |= RTAUDIO_INPUT_OVERFLOW;
+ apiInfo->xrun[1] = false;
+ }
+ doStopStream = callback( stream_.userBuffer[0], stream_.userBuffer[1],
+ stream_.bufferSize, streamTime, status, stream_.callbackInfo.userData );
+
+ if ( doStopStream == 2 ) {
+ abortStream();
+ return;
+ }
+
+ MUTEX_LOCK( &stream_.mutex );
+
+ // The state might change while waiting on a mutex.
+ if ( stream_.state == STREAM_STOPPED ) goto unlock;
+
+ int result;
+ char *buffer;
+ int channels;
+ snd_pcm_t **handle;
+ snd_pcm_sframes_t frames;
+ RtAudioFormat format;
+ handle = (snd_pcm_t **) apiInfo->handles;
+
+ if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
+
+ // Setup parameters.
+ if ( stream_.doConvertBuffer[1] ) {
+ buffer = stream_.deviceBuffer;
+ channels = stream_.nDeviceChannels[1];
+ format = stream_.deviceFormat[1];
+ }
+ else {
+ buffer = stream_.userBuffer[1];
+ channels = stream_.nUserChannels[1];
+ format = stream_.userFormat;
+ }
+
+ // Read samples from device in interleaved/non-interleaved format.
+ if ( stream_.deviceInterleaved[1] )
+ result = snd_pcm_readi( handle[1], buffer, stream_.bufferSize );
+ else {
+ void *bufs[channels];
+ size_t offset = stream_.bufferSize * formatBytes( format );
+ for ( int i=0; i<channels; i++ )
+ bufs[i] = (void *) (buffer + (i * offset));
+ result = snd_pcm_readn( handle[1], bufs, stream_.bufferSize );
+ }
+
+ if ( result < (int) stream_.bufferSize ) {
+ // Either an error or overrun occured.
+ if ( result == -EPIPE ) {
+ snd_pcm_state_t state = snd_pcm_state( handle[1] );
+ if ( state == SND_PCM_STATE_XRUN ) {
+ apiInfo->xrun[1] = true;
+ result = snd_pcm_prepare( handle[1] );
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::callbackEvent: error preparing device after overrun, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ }
+ }
+ else {
+ errorStream_ << "RtApiAlsa::callbackEvent: error, current state is " << snd_pcm_state_name( state ) << ", " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ }
+ }
+ else {
+ errorStream_ << "RtApiAlsa::callbackEvent: audio read error, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ }
+ error( RtAudioError::WARNING );
+ goto tryOutput;
+ }
+
+ // Do byte swapping if necessary.
+ if ( stream_.doByteSwap[1] )
+ byteSwapBuffer( buffer, stream_.bufferSize * channels, format );
+
+ // Do buffer conversion if necessary.
+ if ( stream_.doConvertBuffer[1] )
+ convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] );
+
+ // Check stream latency
+ result = snd_pcm_delay( handle[1], &frames );
+ if ( result == 0 && frames > 0 ) stream_.latency[1] = frames;
+ }
+
+ tryOutput:
+
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+
+ // Setup parameters and do buffer conversion if necessary.
+ if ( stream_.doConvertBuffer[0] ) {
+ buffer = stream_.deviceBuffer;
+ convertBuffer( buffer, stream_.userBuffer[0], stream_.convertInfo[0] );
+ channels = stream_.nDeviceChannels[0];
+ format = stream_.deviceFormat[0];
+ }
+ else {
+ buffer = stream_.userBuffer[0];
+ channels = stream_.nUserChannels[0];
+ format = stream_.userFormat;
+ }
+
+ // Do byte swapping if necessary.
+ if ( stream_.doByteSwap[0] )
+ byteSwapBuffer(buffer, stream_.bufferSize * channels, format);
+
+ // Write samples to device in interleaved/non-interleaved format.
+ if ( stream_.deviceInterleaved[0] )
+ result = snd_pcm_writei( handle[0], buffer, stream_.bufferSize );
+ else {
+ void *bufs[channels];
+ size_t offset = stream_.bufferSize * formatBytes( format );
+ for ( int i=0; i<channels; i++ )
+ bufs[i] = (void *) (buffer + (i * offset));
+ result = snd_pcm_writen( handle[0], bufs, stream_.bufferSize );
+ }
+
+ if ( result < (int) stream_.bufferSize ) {
+ // Either an error or underrun occured.
+ if ( result == -EPIPE ) {
+ snd_pcm_state_t state = snd_pcm_state( handle[0] );
+ if ( state == SND_PCM_STATE_XRUN ) {
+ apiInfo->xrun[0] = true;
+ result = snd_pcm_prepare( handle[0] );
+ if ( result < 0 ) {
+ errorStream_ << "RtApiAlsa::callbackEvent: error preparing device after underrun, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ }
+ else
+ errorText_ = "RtApiAlsa::callbackEvent: audio write error, underrun.";
+ }
+ else {
+ errorStream_ << "RtApiAlsa::callbackEvent: error, current state is " << snd_pcm_state_name( state ) << ", " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ }
+ }
+ else {
+ errorStream_ << "RtApiAlsa::callbackEvent: audio write error, " << snd_strerror( result ) << ".";
+ errorText_ = errorStream_.str();
+ }
+ error( RtAudioError::WARNING );
+ goto unlock;
+ }
+
+ // Check stream latency
+ result = snd_pcm_delay( handle[0], &frames );
+ if ( result == 0 && frames > 0 ) stream_.latency[0] = frames;
+ }
+
+ unlock:
+ MUTEX_UNLOCK( &stream_.mutex );
+
+ RtApi::tickStreamTime();
+ if ( doStopStream == 1 ) this->stopStream();
+}
+
+static void *alsaCallbackHandler( void *ptr )
+{
+ CallbackInfo *info = (CallbackInfo *) ptr;
+ RtApiAlsa *object = (RtApiAlsa *) info->object;
+ bool *isRunning = &info->isRunning;
+
+#ifdef SCHED_RR // Undefined with some OSes (e.g. NetBSD 1.6.x with GNU Pthread)
+ if ( info->doRealtime ) {
+ std::cerr << "RtAudio alsa: " <<
+ (sched_getscheduler(0) == SCHED_RR ? "" : "_NOT_ ") <<
+ "running realtime scheduling" << std::endl;
+ }
+#endif
+
+ while ( *isRunning == true ) {
+ pthread_testcancel();
+ object->callbackEvent();
+ }
+
+ pthread_exit( NULL );
+}
+
+//******************** End of __LINUX_ALSA__ *********************//
+#endif
+
+#if defined(__LINUX_PULSE__)
+
+// Code written by Peter Meerwald, pmeerw@pmeerw.net
+// and Tristan Matthews.
+
+#include <pulse/error.h>
+#include <pulse/simple.h>
+#include <cstdio>
+
+static const unsigned int SUPPORTED_SAMPLERATES[] = { 8000, 16000, 22050, 32000,
+ 44100, 48000, 96000, 0};
+
+struct rtaudio_pa_format_mapping_t {
+ RtAudioFormat rtaudio_format;
+ pa_sample_format_t pa_format;
+};
+
+static const rtaudio_pa_format_mapping_t supported_sampleformats[] = {
+ {RTAUDIO_SINT16, PA_SAMPLE_S16LE},
+ {RTAUDIO_SINT32, PA_SAMPLE_S32LE},
+ {RTAUDIO_FLOAT32, PA_SAMPLE_FLOAT32LE},
+ {0, PA_SAMPLE_INVALID}};
+
+struct PulseAudioHandle {
+ pa_simple *s_play;
+ pa_simple *s_rec;
+ pthread_t thread;
+ pthread_cond_t runnable_cv;
+ bool runnable;
+ PulseAudioHandle() : s_play(0), s_rec(0), runnable(false) { }
+};
+
+RtApiPulse::~RtApiPulse()
+{
+ if ( stream_.state != STREAM_CLOSED )
+ closeStream();
+}
+
+unsigned int RtApiPulse::getDeviceCount( void )
+{
+ return 1;
+}
+
+RtAudio::DeviceInfo RtApiPulse::getDeviceInfo( unsigned int /*device*/ )
+{
+ RtAudio::DeviceInfo info;
+ info.probed = true;
+ info.name = "PulseAudio";
+ info.outputChannels = 2;
+ info.inputChannels = 2;
+ info.duplexChannels = 2;
+ info.isDefaultOutput = true;
+ info.isDefaultInput = true;
+
+ for ( const unsigned int *sr = SUPPORTED_SAMPLERATES; *sr; ++sr )
+ info.sampleRates.push_back( *sr );
+
+ info.preferredSampleRate = 48000;
+ info.nativeFormats = RTAUDIO_SINT16 | RTAUDIO_SINT32 | RTAUDIO_FLOAT32;
+
+ return info;
+}
+
+static void *pulseaudio_callback( void * user )
+{
+ CallbackInfo *cbi = static_cast<CallbackInfo *>( user );
+ RtApiPulse *context = static_cast<RtApiPulse *>( cbi->object );
+ volatile bool *isRunning = &cbi->isRunning;
+
+#ifdef SCHED_RR // Undefined with some OSes (e.g. NetBSD 1.6.x with GNU Pthread)
+ if (cbi->doRealtime) {
+ std::cerr << "RtAudio pulse: " <<
+ (sched_getscheduler(0) == SCHED_RR ? "" : "_NOT_ ") <<
+ "running realtime scheduling" << std::endl;
+ }
+#endif
+
+ while ( *isRunning ) {
+ pthread_testcancel();
+ context->callbackEvent();
+ }
+
+ pthread_exit( NULL );
+}
+
+void RtApiPulse::closeStream( void )
+{
+ PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );
+
+ stream_.callbackInfo.isRunning = false;
+ if ( pah ) {
+ MUTEX_LOCK( &stream_.mutex );
+ if ( stream_.state == STREAM_STOPPED ) {
+ pah->runnable = true;
+ pthread_cond_signal( &pah->runnable_cv );
+ }
+ MUTEX_UNLOCK( &stream_.mutex );
+
+ pthread_join( pah->thread, 0 );
+ if ( pah->s_play ) {
+ pa_simple_flush( pah->s_play, NULL );
+ pa_simple_free( pah->s_play );
+ }
+ if ( pah->s_rec )
+ pa_simple_free( pah->s_rec );
+
+ pthread_cond_destroy( &pah->runnable_cv );
+ delete pah;
+ stream_.apiHandle = 0;
+ }
+
+ if ( stream_.userBuffer[0] ) {
+ free( stream_.userBuffer[0] );
+ stream_.userBuffer[0] = 0;
+ }
+ if ( stream_.userBuffer[1] ) {
+ free( stream_.userBuffer[1] );
+ stream_.userBuffer[1] = 0;
+ }
+
+ stream_.state = STREAM_CLOSED;
+ stream_.mode = UNINITIALIZED;
+}
+
+void RtApiPulse::callbackEvent( void )
+{
+ PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );
+
+ if ( stream_.state == STREAM_STOPPED ) {
+ MUTEX_LOCK( &stream_.mutex );
+ while ( !pah->runnable )
+ pthread_cond_wait( &pah->runnable_cv, &stream_.mutex );
+
+ if ( stream_.state != STREAM_RUNNING ) {
+ MUTEX_UNLOCK( &stream_.mutex );
+ return;
+ }
+ MUTEX_UNLOCK( &stream_.mutex );
+ }
+
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiPulse::callbackEvent(): the stream is closed ... "
+ "this shouldn't happen!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback;
+ double streamTime = getStreamTime();
+ RtAudioStreamStatus status = 0;
+ int doStopStream = callback( stream_.userBuffer[OUTPUT], stream_.userBuffer[INPUT],
+ stream_.bufferSize, streamTime, status,
+ stream_.callbackInfo.userData );
+
+ if ( doStopStream == 2 ) {
+ abortStream();
+ return;
+ }
+
+ MUTEX_LOCK( &stream_.mutex );
+ void *pulse_in = stream_.doConvertBuffer[INPUT] ? stream_.deviceBuffer : stream_.userBuffer[INPUT];
+ void *pulse_out = stream_.doConvertBuffer[OUTPUT] ? stream_.deviceBuffer : stream_.userBuffer[OUTPUT];
+
+ if ( stream_.state != STREAM_RUNNING )
+ goto unlock;
+
+ int pa_error;
+ size_t bytes;
+ if (stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+ if ( stream_.doConvertBuffer[OUTPUT] ) {
+ convertBuffer( stream_.deviceBuffer,
+ stream_.userBuffer[OUTPUT],
+ stream_.convertInfo[OUTPUT] );
+ bytes = stream_.nDeviceChannels[OUTPUT] * stream_.bufferSize *
+ formatBytes( stream_.deviceFormat[OUTPUT] );
+ } else
+ bytes = stream_.nUserChannels[OUTPUT] * stream_.bufferSize *
+ formatBytes( stream_.userFormat );
+
+ if ( pa_simple_write( pah->s_play, pulse_out, bytes, &pa_error ) < 0 ) {
+ errorStream_ << "RtApiPulse::callbackEvent: audio write error, " <<
+ pa_strerror( pa_error ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ }
+ }
+
+ if ( stream_.mode == INPUT || stream_.mode == DUPLEX) {
+ if ( stream_.doConvertBuffer[INPUT] )
+ bytes = stream_.nDeviceChannels[INPUT] * stream_.bufferSize *
+ formatBytes( stream_.deviceFormat[INPUT] );
+ else
+ bytes = stream_.nUserChannels[INPUT] * stream_.bufferSize *
+ formatBytes( stream_.userFormat );
+
+ if ( pa_simple_read( pah->s_rec, pulse_in, bytes, &pa_error ) < 0 ) {
+ errorStream_ << "RtApiPulse::callbackEvent: audio read error, " <<
+ pa_strerror( pa_error ) << ".";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ }
+ if ( stream_.doConvertBuffer[INPUT] ) {
+ convertBuffer( stream_.userBuffer[INPUT],
+ stream_.deviceBuffer,
+ stream_.convertInfo[INPUT] );
+ }
+ }
+
+ unlock:
+ MUTEX_UNLOCK( &stream_.mutex );
+ RtApi::tickStreamTime();
+
+ if ( doStopStream == 1 )
+ stopStream();
+}
+
+void RtApiPulse::startStream( void )
+{
+ PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );
+
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiPulse::startStream(): the stream is not open!";
+ error( RtAudioError::INVALID_USE );
+ return;
+ }
+ if ( stream_.state == STREAM_RUNNING ) {
+ errorText_ = "RtApiPulse::startStream(): the stream is already running!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ MUTEX_LOCK( &stream_.mutex );
+
+ #if defined( HAVE_GETTIMEOFDAY )
+ gettimeofday( &stream_.lastTickTimestamp, NULL );
+ #endif
+
+ stream_.state = STREAM_RUNNING;
+
+ pah->runnable = true;
+ pthread_cond_signal( &pah->runnable_cv );
+ MUTEX_UNLOCK( &stream_.mutex );
+}
+
+void RtApiPulse::stopStream( void )
+{
+ PulseAudioHandle *pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );
+
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiPulse::stopStream(): the stream is not open!";
+ error( RtAudioError::INVALID_USE );
+ return;
+ }
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiPulse::stopStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ stream_.state = STREAM_STOPPED;
+ MUTEX_LOCK( &stream_.mutex );
+
+ if ( pah && pah->s_play ) {
+ int pa_error;
+ if ( pa_simple_drain( pah->s_play, &pa_error ) < 0 ) {
+ errorStream_ << "RtApiPulse::stopStream: error draining output device, " <<
+ pa_strerror( pa_error ) << ".";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+ }
+
+ stream_.state = STREAM_STOPPED;
+ MUTEX_UNLOCK( &stream_.mutex );
+}
+
+void RtApiPulse::abortStream( void )
+{
+ PulseAudioHandle *pah = static_cast<PulseAudioHandle*>( stream_.apiHandle );
+
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiPulse::abortStream(): the stream is not open!";
+ error( RtAudioError::INVALID_USE );
+ return;
+ }
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiPulse::abortStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ stream_.state = STREAM_STOPPED;
+ MUTEX_LOCK( &stream_.mutex );
+
+ if ( pah && pah->s_play ) {
+ int pa_error;
+ if ( pa_simple_flush( pah->s_play, &pa_error ) < 0 ) {
+ errorStream_ << "RtApiPulse::abortStream: error flushing output device, " <<
+ pa_strerror( pa_error ) << ".";
+ errorText_ = errorStream_.str();
+ MUTEX_UNLOCK( &stream_.mutex );
+ error( RtAudioError::SYSTEM_ERROR );
+ return;
+ }
+ }
+
+ stream_.state = STREAM_STOPPED;
+ MUTEX_UNLOCK( &stream_.mutex );
+}
+
+bool RtApiPulse::probeDeviceOpen( unsigned int device, StreamMode mode,
+ unsigned int channels, unsigned int firstChannel,
+ unsigned int sampleRate, RtAudioFormat format,
+ unsigned int *bufferSize, RtAudio::StreamOptions *options )
+{
+ PulseAudioHandle *pah = 0;
+ unsigned long bufferBytes = 0;
+ pa_sample_spec ss;
+
+ if ( device != 0 ) return false;
+ if ( mode != INPUT && mode != OUTPUT ) return false;
+ if ( channels != 1 && channels != 2 ) {
+ errorText_ = "RtApiPulse::probeDeviceOpen: unsupported number of channels.";
+ return false;
+ }
+ ss.channels = channels;
+
+ if ( firstChannel != 0 ) return false;
+
+ bool sr_found = false;
+ for ( const unsigned int *sr = SUPPORTED_SAMPLERATES; *sr; ++sr ) {
+ if ( sampleRate == *sr ) {
+ sr_found = true;
+ stream_.sampleRate = sampleRate;
+ ss.rate = sampleRate;
+ break;
+ }
+ }
+ if ( !sr_found ) {
+ errorText_ = "RtApiPulse::probeDeviceOpen: unsupported sample rate.";
+ return false;
+ }
+
+ bool sf_found = 0;
+ for ( const rtaudio_pa_format_mapping_t *sf = supported_sampleformats;
+ sf->rtaudio_format && sf->pa_format != PA_SAMPLE_INVALID; ++sf ) {
+ if ( format == sf->rtaudio_format ) {
+ sf_found = true;
+ stream_.userFormat = sf->rtaudio_format;
+ stream_.deviceFormat[mode] = stream_.userFormat;
+ ss.format = sf->pa_format;
+ break;
+ }
+ }
+ if ( !sf_found ) { // Use internal data format conversion.
+ stream_.userFormat = format;
+ stream_.deviceFormat[mode] = RTAUDIO_FLOAT32;
+ ss.format = PA_SAMPLE_FLOAT32LE;
+ }
+
+ // Set other stream parameters.
+ if ( options && options->flags & RTAUDIO_NONINTERLEAVED ) stream_.userInterleaved = false;
+ else stream_.userInterleaved = true;
+ stream_.deviceInterleaved[mode] = true;
+ stream_.nBuffers = 1;
+ stream_.doByteSwap[mode] = false;
+ stream_.nUserChannels[mode] = channels;
+ stream_.nDeviceChannels[mode] = channels + firstChannel;
+ stream_.channelOffset[mode] = 0;
+ std::string streamName = "RtAudio";
+
+ // Set flags for buffer conversion.
+ stream_.doConvertBuffer[mode] = false;
+ if ( stream_.userFormat != stream_.deviceFormat[mode] )
+ stream_.doConvertBuffer[mode] = true;
+ if ( stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode] )
+ stream_.doConvertBuffer[mode] = true;
+
+ // Allocate necessary internal buffers.
+ bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
+ stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
+ if ( stream_.userBuffer[mode] == NULL ) {
+ errorText_ = "RtApiPulse::probeDeviceOpen: error allocating user buffer memory.";
+ goto error;
+ }
+ stream_.bufferSize = *bufferSize;
+
+ if ( stream_.doConvertBuffer[mode] ) {
+
+ bool makeBuffer = true;
+ bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] );
+ if ( mode == INPUT ) {
+ if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) {
+ unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
+ if ( bufferBytes <= bytesOut ) makeBuffer = false;
+ }
+ }
+
+ if ( makeBuffer ) {
+ bufferBytes *= *bufferSize;
+ if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
+ stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
+ if ( stream_.deviceBuffer == NULL ) {
+ errorText_ = "RtApiPulse::probeDeviceOpen: error allocating device buffer memory.";
+ goto error;
+ }
+ }
+ }
+
+ stream_.device[mode] = device;
+
+ // Setup the buffer conversion information structure.
+ if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, firstChannel );
+
+ if ( !stream_.apiHandle ) {
+ PulseAudioHandle *pah = new PulseAudioHandle;
+ if ( !pah ) {
+ errorText_ = "RtApiPulse::probeDeviceOpen: error allocating memory for handle.";
+ goto error;
+ }
+
+ stream_.apiHandle = pah;
+ if ( pthread_cond_init( &pah->runnable_cv, NULL ) != 0 ) {
+ errorText_ = "RtApiPulse::probeDeviceOpen: error creating condition variable.";
+ goto error;
+ }
+ }
+ pah = static_cast<PulseAudioHandle *>( stream_.apiHandle );
+
+ int error;
+ if ( options && !options->streamName.empty() ) streamName = options->streamName;
+ switch ( mode ) {
+ case INPUT:
+ pa_buffer_attr buffer_attr;
+ buffer_attr.fragsize = bufferBytes;
+ buffer_attr.maxlength = -1;
+
+ pah->s_rec = pa_simple_new( NULL, streamName.c_str(), PA_STREAM_RECORD, NULL, "Record", &ss, NULL, &buffer_attr, &error );
+ if ( !pah->s_rec ) {
+ errorText_ = "RtApiPulse::probeDeviceOpen: error connecting input to PulseAudio server.";
+ goto error;
+ }
+ break;
+ case OUTPUT:
+ pah->s_play = pa_simple_new( NULL, streamName.c_str(), PA_STREAM_PLAYBACK, NULL, "Playback", &ss, NULL, NULL, &error );
+ if ( !pah->s_play ) {
+ errorText_ = "RtApiPulse::probeDeviceOpen: error connecting output to PulseAudio server.";
+ goto error;
+ }
+ break;
+ default:
+ goto error;
+ }
+
+ if ( stream_.mode == UNINITIALIZED )
+ stream_.mode = mode;
+ else if ( stream_.mode == mode )
+ goto error;
+ else
+ stream_.mode = DUPLEX;
+
+ if ( !stream_.callbackInfo.isRunning ) {
+ stream_.callbackInfo.object = this;
+
+ stream_.state = STREAM_STOPPED;
+ // Set the thread attributes for joinable and realtime scheduling
+ // priority (optional). The higher priority will only take affect
+ // if the program is run as root or suid. Note, under Linux
+ // processes with CAP_SYS_NICE privilege, a user can change
+ // scheduling policy and priority (thus need not be root). See
+ // POSIX "capabilities".
+ pthread_attr_t attr;
+ pthread_attr_init( &attr );
+ pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
+#ifdef SCHED_RR // Undefined with some OSes (e.g. NetBSD 1.6.x with GNU Pthread)
+ if ( options && options->flags & RTAUDIO_SCHEDULE_REALTIME ) {
+ stream_.callbackInfo.doRealtime = true;
+ struct sched_param param;
+ int priority = options->priority;
+ int min = sched_get_priority_min( SCHED_RR );
+ int max = sched_get_priority_max( SCHED_RR );
+ if ( priority < min ) priority = min;
+ else if ( priority > max ) priority = max;
+ param.sched_priority = priority;
+
+ // Set the policy BEFORE the priority. Otherwise it fails.
+ pthread_attr_setschedpolicy(&attr, SCHED_RR);
+ pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);
+ // This is definitely required. Otherwise it fails.
+ pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
+ pthread_attr_setschedparam(&attr, ¶m);
+ }
+ else
+ pthread_attr_setschedpolicy( &attr, SCHED_OTHER );
+#else
+ pthread_attr_setschedpolicy( &attr, SCHED_OTHER );
+#endif
+
+ stream_.callbackInfo.isRunning = true;
+ int result = pthread_create( &pah->thread, &attr, pulseaudio_callback, (void *)&stream_.callbackInfo);
+ pthread_attr_destroy(&attr);
+ if(result != 0) {
+ // Failed. Try instead with default attributes.
+ result = pthread_create( &pah->thread, NULL, pulseaudio_callback, (void *)&stream_.callbackInfo);
+ if(result != 0) {
+ stream_.callbackInfo.isRunning = false;
+ errorText_ = "RtApiPulse::probeDeviceOpen: error creating thread.";
+ goto error;
+ }
+ }
+ }
+
+ return SUCCESS;
+
+ error:
+ if ( pah && stream_.callbackInfo.isRunning ) {
+ pthread_cond_destroy( &pah->runnable_cv );
+ delete pah;
+ stream_.apiHandle = 0;
+ }
+
+ for ( int i=0; i<2; i++ ) {
+ if ( stream_.userBuffer[i] ) {
+ free( stream_.userBuffer[i] );
+ stream_.userBuffer[i] = 0;
+ }
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+
+ stream_.state = STREAM_CLOSED;
+ return FAILURE;
+}
+
+//******************** End of __LINUX_PULSE__ *********************//
+#endif
+
+#if defined(__LINUX_OSS__)
+
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/soundcard.h>
+#include <errno.h>
+#include <math.h>
+
+static void *ossCallbackHandler(void * ptr);
+
+// A structure to hold various information related to the OSS API
+// implementation.
+struct OssHandle {
+ int id[2]; // device ids
+ bool xrun[2];
+ bool triggered;
+ pthread_cond_t runnable;
+
+ OssHandle()
+ :triggered(false) { id[0] = 0; id[1] = 0; xrun[0] = false; xrun[1] = false; }
+};
+
+RtApiOss :: RtApiOss()
+{
+ // Nothing to do here.
+}
+
+RtApiOss :: ~RtApiOss()
+{
+ if ( stream_.state != STREAM_CLOSED ) closeStream();
+}
+
+unsigned int RtApiOss :: getDeviceCount( void )
+{
+ int mixerfd = open( "/dev/mixer", O_RDWR, 0 );
+ if ( mixerfd == -1 ) {
+ errorText_ = "RtApiOss::getDeviceCount: error opening '/dev/mixer'.";
+ error( RtAudioError::WARNING );
+ return 0;
+ }
+
+ oss_sysinfo sysinfo;
+ if ( ioctl( mixerfd, SNDCTL_SYSINFO, &sysinfo ) == -1 ) {
+ close( mixerfd );
+ errorText_ = "RtApiOss::getDeviceCount: error getting sysinfo, OSS version >= 4.0 is required.";
+ error( RtAudioError::WARNING );
+ return 0;
+ }
+
+ close( mixerfd );
+ return sysinfo.numaudios;
+}
+
+RtAudio::DeviceInfo RtApiOss :: getDeviceInfo( unsigned int device )
+{
+ RtAudio::DeviceInfo info;
+ info.probed = false;
+
+ int mixerfd = open( "/dev/mixer", O_RDWR, 0 );
+ if ( mixerfd == -1 ) {
+ errorText_ = "RtApiOss::getDeviceInfo: error opening '/dev/mixer'.";
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ oss_sysinfo sysinfo;
+ int result = ioctl( mixerfd, SNDCTL_SYSINFO, &sysinfo );
+ if ( result == -1 ) {
+ close( mixerfd );
+ errorText_ = "RtApiOss::getDeviceInfo: error getting sysinfo, OSS version >= 4.0 is required.";
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ unsigned nDevices = sysinfo.numaudios;
+ if ( nDevices == 0 ) {
+ close( mixerfd );
+ errorText_ = "RtApiOss::getDeviceInfo: no devices found!";
+ error( RtAudioError::INVALID_USE );
+ return info;
+ }
+
+ if ( device >= nDevices ) {
+ close( mixerfd );
+ errorText_ = "RtApiOss::getDeviceInfo: device ID is invalid!";
+ error( RtAudioError::INVALID_USE );
+ return info;
+ }
+
+ oss_audioinfo ainfo;
+ ainfo.dev = device;
+ result = ioctl( mixerfd, SNDCTL_AUDIOINFO, &ainfo );
+ close( mixerfd );
+ if ( result == -1 ) {
+ errorStream_ << "RtApiOss::getDeviceInfo: error getting device (" << ainfo.name << ") info.";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // Probe channels
+ if ( ainfo.caps & PCM_CAP_OUTPUT ) info.outputChannels = ainfo.max_channels;
+ if ( ainfo.caps & PCM_CAP_INPUT ) info.inputChannels = ainfo.max_channels;
+ if ( ainfo.caps & PCM_CAP_DUPLEX ) {
+ if ( info.outputChannels > 0 && info.inputChannels > 0 && ainfo.caps & PCM_CAP_DUPLEX )
+ info.duplexChannels = (info.outputChannels > info.inputChannels) ? info.inputChannels : info.outputChannels;
+ }
+
+ // Probe data formats ... do for input
+ unsigned long mask = ainfo.iformats;
+ if ( mask & AFMT_S16_LE || mask & AFMT_S16_BE )
+ info.nativeFormats |= RTAUDIO_SINT16;
+ if ( mask & AFMT_S8 )
+ info.nativeFormats |= RTAUDIO_SINT8;
+ if ( mask & AFMT_S32_LE || mask & AFMT_S32_BE )
+ info.nativeFormats |= RTAUDIO_SINT32;
+#ifdef AFMT_FLOAT
+ if ( mask & AFMT_FLOAT )
+ info.nativeFormats |= RTAUDIO_FLOAT32;
+#endif
+ if ( mask & AFMT_S24_LE || mask & AFMT_S24_BE )
+ info.nativeFormats |= RTAUDIO_SINT24;
+
+ // Check that we have at least one supported format
+ if ( info.nativeFormats == 0 ) {
+ errorStream_ << "RtApiOss::getDeviceInfo: device (" << ainfo.name << ") data format not supported by RtAudio.";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ return info;
+ }
+
+ // Probe the supported sample rates.
+ info.sampleRates.clear();
+ if ( ainfo.nrates ) {
+ for ( unsigned int i=0; i<ainfo.nrates; i++ ) {
+ for ( unsigned int k=0; k<MAX_SAMPLE_RATES; k++ ) {
+ if ( ainfo.rates[i] == SAMPLE_RATES[k] ) {
+ info.sampleRates.push_back( SAMPLE_RATES[k] );
+
+ if ( !info.preferredSampleRate || ( SAMPLE_RATES[k] <= 48000 && SAMPLE_RATES[k] > info.preferredSampleRate ) )
+ info.preferredSampleRate = SAMPLE_RATES[k];
+
+ break;
+ }
+ }
+ }
+ }
+ else {
+ // Check min and max rate values;
+ for ( unsigned int k=0; k<MAX_SAMPLE_RATES; k++ ) {
+ if ( ainfo.min_rate <= (int) SAMPLE_RATES[k] && ainfo.max_rate >= (int) SAMPLE_RATES[k] ) {
+ info.sampleRates.push_back( SAMPLE_RATES[k] );
+
+ if ( !info.preferredSampleRate || ( SAMPLE_RATES[k] <= 48000 && SAMPLE_RATES[k] > info.preferredSampleRate ) )
+ info.preferredSampleRate = SAMPLE_RATES[k];
+ }
+ }
+ }
+
+ if ( info.sampleRates.size() == 0 ) {
+ errorStream_ << "RtApiOss::getDeviceInfo: no supported sample rates found for device (" << ainfo.name << ").";
+ errorText_ = errorStream_.str();
+ error( RtAudioError::WARNING );
+ }
+ else {
+ info.probed = true;
+ info.name = ainfo.name;
+ }
+
+ return info;
+}
+
+
+bool RtApiOss :: probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options )
+{
+ int mixerfd = open( "/dev/mixer", O_RDWR, 0 );
+ if ( mixerfd == -1 ) {
+ errorText_ = "RtApiOss::probeDeviceOpen: error opening '/dev/mixer'.";
+ return FAILURE;
+ }
+
+ oss_sysinfo sysinfo;
+ int result = ioctl( mixerfd, SNDCTL_SYSINFO, &sysinfo );
+ if ( result == -1 ) {
+ close( mixerfd );
+ errorText_ = "RtApiOss::probeDeviceOpen: error getting sysinfo, OSS version >= 4.0 is required.";
+ return FAILURE;
+ }
+
+ unsigned nDevices = sysinfo.numaudios;
+ if ( nDevices == 0 ) {
+ // This should not happen because a check is made before this function is called.
+ close( mixerfd );
+ errorText_ = "RtApiOss::probeDeviceOpen: no devices found!";
+ return FAILURE;
+ }
+
+ if ( device >= nDevices ) {
+ // This should not happen because a check is made before this function is called.
+ close( mixerfd );
+ errorText_ = "RtApiOss::probeDeviceOpen: device ID is invalid!";
+ return FAILURE;
+ }
+
+ oss_audioinfo ainfo;
+ ainfo.dev = device;
+ result = ioctl( mixerfd, SNDCTL_AUDIOINFO, &ainfo );
+ close( mixerfd );
+ if ( result == -1 ) {
+ errorStream_ << "RtApiOss::getDeviceInfo: error getting device (" << ainfo.name << ") info.";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Check if device supports input or output
+ if ( ( mode == OUTPUT && !( ainfo.caps & PCM_CAP_OUTPUT ) ) ||
+ ( mode == INPUT && !( ainfo.caps & PCM_CAP_INPUT ) ) ) {
+ if ( mode == OUTPUT )
+ errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") does not support output.";
+ else
+ errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") does not support input.";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ int flags = 0;
+ OssHandle *handle = (OssHandle *) stream_.apiHandle;
+ if ( mode == OUTPUT )
+ flags |= O_WRONLY;
+ else { // mode == INPUT
+ if (stream_.mode == OUTPUT && stream_.device[0] == device) {
+ // We just set the same device for playback ... close and reopen for duplex (OSS only).
+ close( handle->id[0] );
+ handle->id[0] = 0;
+ if ( !( ainfo.caps & PCM_CAP_DUPLEX ) ) {
+ errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") does not support duplex mode.";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ // Check that the number previously set channels is the same.
+ if ( stream_.nUserChannels[0] != channels ) {
+ errorStream_ << "RtApiOss::probeDeviceOpen: input/output channels must be equal for OSS duplex device (" << ainfo.name << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ flags |= O_RDWR;
+ }
+ else
+ flags |= O_RDONLY;
+ }
+
+ // Set exclusive access if specified.
+ if ( options && options->flags & RTAUDIO_HOG_DEVICE ) flags |= O_EXCL;
+
+ // Try to open the device.
+ int fd;
+ fd = open( ainfo.devnode, flags, 0 );
+ if ( fd == -1 ) {
+ if ( errno == EBUSY )
+ errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") is busy.";
+ else
+ errorStream_ << "RtApiOss::probeDeviceOpen: error opening device (" << ainfo.name << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // For duplex operation, specifically set this mode (this doesn't seem to work).
+ /*
+ if ( flags | O_RDWR ) {
+ result = ioctl( fd, SNDCTL_DSP_SETDUPLEX, NULL );
+ if ( result == -1) {
+ errorStream_ << "RtApiOss::probeDeviceOpen: error setting duplex mode for device (" << ainfo.name << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ }
+ */
+
+ // Check the device channel support.
+ stream_.nUserChannels[mode] = channels;
+ if ( ainfo.max_channels < (int)(channels + firstChannel) ) {
+ close( fd );
+ errorStream_ << "RtApiOss::probeDeviceOpen: the device (" << ainfo.name << ") does not support requested channel parameters.";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Set the number of channels.
+ int deviceChannels = channels + firstChannel;
+ result = ioctl( fd, SNDCTL_DSP_CHANNELS, &deviceChannels );
+ if ( result == -1 || deviceChannels < (int)(channels + firstChannel) ) {
+ close( fd );
+ errorStream_ << "RtApiOss::probeDeviceOpen: error setting channel parameters on device (" << ainfo.name << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ stream_.nDeviceChannels[mode] = deviceChannels;
+
+ // Get the data format mask
+ int mask;
+ result = ioctl( fd, SNDCTL_DSP_GETFMTS, &mask );
+ if ( result == -1 ) {
+ close( fd );
+ errorStream_ << "RtApiOss::probeDeviceOpen: error getting device (" << ainfo.name << ") data formats.";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Determine how to set the device format.
+ stream_.userFormat = format;
+ int deviceFormat = -1;
+ stream_.doByteSwap[mode] = false;
+ if ( format == RTAUDIO_SINT8 ) {
+ if ( mask & AFMT_S8 ) {
+ deviceFormat = AFMT_S8;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT8;
+ }
+ }
+ else if ( format == RTAUDIO_SINT16 ) {
+ if ( mask & AFMT_S16_NE ) {
+ deviceFormat = AFMT_S16_NE;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT16;
+ }
+ else if ( mask & AFMT_S16_OE ) {
+ deviceFormat = AFMT_S16_OE;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT16;
+ stream_.doByteSwap[mode] = true;
+ }
+ }
+ else if ( format == RTAUDIO_SINT24 ) {
+ if ( mask & AFMT_S24_NE ) {
+ deviceFormat = AFMT_S24_NE;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT24;
+ }
+ else if ( mask & AFMT_S24_OE ) {
+ deviceFormat = AFMT_S24_OE;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT24;
+ stream_.doByteSwap[mode] = true;
+ }
+ }
+ else if ( format == RTAUDIO_SINT32 ) {
+ if ( mask & AFMT_S32_NE ) {
+ deviceFormat = AFMT_S32_NE;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT32;
+ }
+ else if ( mask & AFMT_S32_OE ) {
+ deviceFormat = AFMT_S32_OE;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT32;
+ stream_.doByteSwap[mode] = true;
+ }
+ }
+
+ if ( deviceFormat == -1 ) {
+ // The user requested format is not natively supported by the device.
+ if ( mask & AFMT_S16_NE ) {
+ deviceFormat = AFMT_S16_NE;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT16;
+ }
+ else if ( mask & AFMT_S32_NE ) {
+ deviceFormat = AFMT_S32_NE;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT32;
+ }
+ else if ( mask & AFMT_S24_NE ) {
+ deviceFormat = AFMT_S24_NE;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT24;
+ }
+ else if ( mask & AFMT_S16_OE ) {
+ deviceFormat = AFMT_S16_OE;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT16;
+ stream_.doByteSwap[mode] = true;
+ }
+ else if ( mask & AFMT_S32_OE ) {
+ deviceFormat = AFMT_S32_OE;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT32;
+ stream_.doByteSwap[mode] = true;
+ }
+ else if ( mask & AFMT_S24_OE ) {
+ deviceFormat = AFMT_S24_OE;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT24;
+ stream_.doByteSwap[mode] = true;
+ }
+ else if ( mask & AFMT_S8) {
+ deviceFormat = AFMT_S8;
+ stream_.deviceFormat[mode] = RTAUDIO_SINT8;
+ }
+ }
+
+ if ( stream_.deviceFormat[mode] == 0 ) {
+ // This really shouldn't happen ...
+ close( fd );
+ errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") data format not supported by RtAudio.";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Set the data format.
+ int temp = deviceFormat;
+ result = ioctl( fd, SNDCTL_DSP_SETFMT, &deviceFormat );
+ if ( result == -1 || deviceFormat != temp ) {
+ close( fd );
+ errorStream_ << "RtApiOss::probeDeviceOpen: error setting data format on device (" << ainfo.name << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Attempt to set the buffer size. According to OSS, the minimum
+ // number of buffers is two. The supposed minimum buffer size is 16
+ // bytes, so that will be our lower bound. The argument to this
+ // call is in the form 0xMMMMSSSS (hex), where the buffer size (in
+ // bytes) is given as 2^SSSS and the number of buffers as 2^MMMM.
+ // We'll check the actual value used near the end of the setup
+ // procedure.
+ int ossBufferBytes = *bufferSize * formatBytes( stream_.deviceFormat[mode] ) * deviceChannels;
+ if ( ossBufferBytes < 16 ) ossBufferBytes = 16;
+ int buffers = 0;
+ if ( options ) buffers = options->numberOfBuffers;
+ if ( options && options->flags & RTAUDIO_MINIMIZE_LATENCY ) buffers = 2;
+ if ( buffers < 2 ) buffers = 3;
+ temp = ((int) buffers << 16) + (int)( log10( (double)ossBufferBytes ) / log10( 2.0 ) );
+ result = ioctl( fd, SNDCTL_DSP_SETFRAGMENT, &temp );
+ if ( result == -1 ) {
+ close( fd );
+ errorStream_ << "RtApiOss::probeDeviceOpen: error setting buffer size on device (" << ainfo.name << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ stream_.nBuffers = buffers;
+
+ // Save buffer size (in sample frames).
+ *bufferSize = ossBufferBytes / ( formatBytes(stream_.deviceFormat[mode]) * deviceChannels );
+ stream_.bufferSize = *bufferSize;
+
+ // Set the sample rate.
+ int srate = sampleRate;
+ result = ioctl( fd, SNDCTL_DSP_SPEED, &srate );
+ if ( result == -1 ) {
+ close( fd );
+ errorStream_ << "RtApiOss::probeDeviceOpen: error setting sample rate (" << sampleRate << ") on device (" << ainfo.name << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+
+ // Verify the sample rate setup worked.
+ if ( abs( srate - (int)sampleRate ) > 100 ) {
+ close( fd );
+ errorStream_ << "RtApiOss::probeDeviceOpen: device (" << ainfo.name << ") does not support sample rate (" << sampleRate << ").";
+ errorText_ = errorStream_.str();
+ return FAILURE;
+ }
+ stream_.sampleRate = sampleRate;
+
+ if ( mode == INPUT && stream_.mode == OUTPUT && stream_.device[0] == device) {
+ // We're doing duplex setup here.
+ stream_.deviceFormat[0] = stream_.deviceFormat[1];
+ stream_.nDeviceChannels[0] = deviceChannels;
+ }
+
+ // Set interleaving parameters.
+ stream_.userInterleaved = true;
+ stream_.deviceInterleaved[mode] = true;
+ if ( options && options->flags & RTAUDIO_NONINTERLEAVED )
+ stream_.userInterleaved = false;
+
+ // Set flags for buffer conversion
+ stream_.doConvertBuffer[mode] = false;
+ if ( stream_.userFormat != stream_.deviceFormat[mode] )
+ stream_.doConvertBuffer[mode] = true;
+ if ( stream_.nUserChannels[mode] < stream_.nDeviceChannels[mode] )
+ stream_.doConvertBuffer[mode] = true;
+ if ( stream_.userInterleaved != stream_.deviceInterleaved[mode] &&
+ stream_.nUserChannels[mode] > 1 )
+ stream_.doConvertBuffer[mode] = true;
+
+ // Allocate the stream handles if necessary and then save.
+ if ( stream_.apiHandle == 0 ) {
+ try {
+ handle = new OssHandle;
+ }
+ catch ( std::bad_alloc& ) {
+ errorText_ = "RtApiOss::probeDeviceOpen: error allocating OssHandle memory.";
+ goto error;
+ }
+
+ if ( pthread_cond_init( &handle->runnable, NULL ) ) {
+ errorText_ = "RtApiOss::probeDeviceOpen: error initializing pthread condition variable.";
+ goto error;
+ }
+
+ stream_.apiHandle = (void *) handle;
+ }
+ else {
+ handle = (OssHandle *) stream_.apiHandle;
+ }
+ handle->id[mode] = fd;
+
+ // Allocate necessary internal buffers.
+ unsigned long bufferBytes;
+ bufferBytes = stream_.nUserChannels[mode] * *bufferSize * formatBytes( stream_.userFormat );
+ stream_.userBuffer[mode] = (char *) calloc( bufferBytes, 1 );
+ if ( stream_.userBuffer[mode] == NULL ) {
+ errorText_ = "RtApiOss::probeDeviceOpen: error allocating user buffer memory.";
+ goto error;
+ }
+
+ if ( stream_.doConvertBuffer[mode] ) {
+
+ bool makeBuffer = true;
+ bufferBytes = stream_.nDeviceChannels[mode] * formatBytes( stream_.deviceFormat[mode] );
+ if ( mode == INPUT ) {
+ if ( stream_.mode == OUTPUT && stream_.deviceBuffer ) {
+ unsigned long bytesOut = stream_.nDeviceChannels[0] * formatBytes( stream_.deviceFormat[0] );
+ if ( bufferBytes <= bytesOut ) makeBuffer = false;
+ }
+ }
+
+ if ( makeBuffer ) {
+ bufferBytes *= *bufferSize;
+ if ( stream_.deviceBuffer ) free( stream_.deviceBuffer );
+ stream_.deviceBuffer = (char *) calloc( bufferBytes, 1 );
+ if ( stream_.deviceBuffer == NULL ) {
+ errorText_ = "RtApiOss::probeDeviceOpen: error allocating device buffer memory.";
+ goto error;
+ }
+ }
+ }
+
+ stream_.device[mode] = device;
+ stream_.state = STREAM_STOPPED;
+
+ // Setup the buffer conversion information structure.
+ if ( stream_.doConvertBuffer[mode] ) setConvertInfo( mode, firstChannel );
+
+ // Setup thread if necessary.
+ if ( stream_.mode == OUTPUT && mode == INPUT ) {
+ // We had already set up an output stream.
+ stream_.mode = DUPLEX;
+ if ( stream_.device[0] == device ) handle->id[0] = fd;
+ }
+ else {
+ stream_.mode = mode;
+
+ // Setup callback thread.
+ stream_.callbackInfo.object = (void *) this;
+
+ // Set the thread attributes for joinable and realtime scheduling
+ // priority. The higher priority will only take affect if the
+ // program is run as root or suid.
+ pthread_attr_t attr;
+ pthread_attr_init( &attr );
+ pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_JOINABLE );
+#ifdef SCHED_RR // Undefined with some OSes (e.g. NetBSD 1.6.x with GNU Pthread)
+ if ( options && options->flags & RTAUDIO_SCHEDULE_REALTIME ) {
+ stream_.callbackInfo.doRealtime = true;
+ struct sched_param param;
+ int priority = options->priority;
+ int min = sched_get_priority_min( SCHED_RR );
+ int max = sched_get_priority_max( SCHED_RR );
+ if ( priority < min ) priority = min;
+ else if ( priority > max ) priority = max;
+ param.sched_priority = priority;
+
+ // Set the policy BEFORE the priority. Otherwise it fails.
+ pthread_attr_setschedpolicy(&attr, SCHED_RR);
+ pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);
+ // This is definitely required. Otherwise it fails.
+ pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
+ pthread_attr_setschedparam(&attr, ¶m);
+ }
+ else
+ pthread_attr_setschedpolicy( &attr, SCHED_OTHER );
+#else
+ pthread_attr_setschedpolicy( &attr, SCHED_OTHER );
+#endif
+
+ stream_.callbackInfo.isRunning = true;
+ result = pthread_create( &stream_.callbackInfo.thread, &attr, ossCallbackHandler, &stream_.callbackInfo );
+ pthread_attr_destroy( &attr );
+ if ( result ) {
+ // Failed. Try instead with default attributes.
+ result = pthread_create( &stream_.callbackInfo.thread, NULL, ossCallbackHandler, &stream_.callbackInfo );
+ if ( result ) {
+ stream_.callbackInfo.isRunning = false;
+ errorText_ = "RtApiOss::error creating callback thread!";
+ goto error;
+ }
+ }
+ }
+
+ return SUCCESS;
+
+ error:
+ if ( handle ) {
+ pthread_cond_destroy( &handle->runnable );
+ if ( handle->id[0] ) close( handle->id[0] );
+ if ( handle->id[1] ) close( handle->id[1] );
+ delete handle;
+ stream_.apiHandle = 0;
+ }
+
+ for ( int i=0; i<2; i++ ) {
+ if ( stream_.userBuffer[i] ) {
+ free( stream_.userBuffer[i] );
+ stream_.userBuffer[i] = 0;
+ }
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+
+ stream_.state = STREAM_CLOSED;
+ return FAILURE;
+}
+
+void RtApiOss :: closeStream()
+{
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiOss::closeStream(): no open stream to close!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ OssHandle *handle = (OssHandle *) stream_.apiHandle;
+ stream_.callbackInfo.isRunning = false;
+ MUTEX_LOCK( &stream_.mutex );
+ if ( stream_.state == STREAM_STOPPED )
+ pthread_cond_signal( &handle->runnable );
+ MUTEX_UNLOCK( &stream_.mutex );
+ pthread_join( stream_.callbackInfo.thread, NULL );
+
+ if ( stream_.state == STREAM_RUNNING ) {
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX )
+ ioctl( handle->id[0], SNDCTL_DSP_HALT, 0 );
+ else
+ ioctl( handle->id[1], SNDCTL_DSP_HALT, 0 );
+ stream_.state = STREAM_STOPPED;
+ }
+
+ if ( handle ) {
+ pthread_cond_destroy( &handle->runnable );
+ if ( handle->id[0] ) close( handle->id[0] );
+ if ( handle->id[1] ) close( handle->id[1] );
+ delete handle;
+ stream_.apiHandle = 0;
+ }
+
+ for ( int i=0; i<2; i++ ) {
+ if ( stream_.userBuffer[i] ) {
+ free( stream_.userBuffer[i] );
+ stream_.userBuffer[i] = 0;
+ }
+ }
+
+ if ( stream_.deviceBuffer ) {
+ free( stream_.deviceBuffer );
+ stream_.deviceBuffer = 0;
+ }
+
+ stream_.mode = UNINITIALIZED;
+ stream_.state = STREAM_CLOSED;
+}
+
+void RtApiOss :: startStream()
+{
+ verifyStream();
+ if ( stream_.state == STREAM_RUNNING ) {
+ errorText_ = "RtApiOss::startStream(): the stream is already running!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ MUTEX_LOCK( &stream_.mutex );
+
+ #if defined( HAVE_GETTIMEOFDAY )
+ gettimeofday( &stream_.lastTickTimestamp, NULL );
+ #endif
+
+ stream_.state = STREAM_RUNNING;
+
+ // No need to do anything else here ... OSS automatically starts
+ // when fed samples.
+
+ MUTEX_UNLOCK( &stream_.mutex );
+
+ OssHandle *handle = (OssHandle *) stream_.apiHandle;
+ pthread_cond_signal( &handle->runnable );
+}
+
+void RtApiOss :: stopStream()
+{
+ verifyStream();
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiOss::stopStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ MUTEX_LOCK( &stream_.mutex );
+
+ // The state might change while waiting on a mutex.
+ if ( stream_.state == STREAM_STOPPED ) {
+ MUTEX_UNLOCK( &stream_.mutex );
+ return;
+ }
+
+ int result = 0;
+ OssHandle *handle = (OssHandle *) stream_.apiHandle;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+
+ // Flush the output with zeros a few times.
+ char *buffer;
+ int samples;
+ RtAudioFormat format;
+
+ if ( stream_.doConvertBuffer[0] ) {
+ buffer = stream_.deviceBuffer;
+ samples = stream_.bufferSize * stream_.nDeviceChannels[0];
+ format = stream_.deviceFormat[0];
+ }
+ else {
+ buffer = stream_.userBuffer[0];
+ samples = stream_.bufferSize * stream_.nUserChannels[0];
+ format = stream_.userFormat;
+ }
+
+ memset( buffer, 0, samples * formatBytes(format) );
+ for ( unsigned int i=0; i<stream_.nBuffers+1; i++ ) {
+ result = write( handle->id[0], buffer, samples * formatBytes(format) );
+ if ( result == -1 ) {
+ errorText_ = "RtApiOss::stopStream: audio write error.";
+ error( RtAudioError::WARNING );
+ }
+ }
+
+ result = ioctl( handle->id[0], SNDCTL_DSP_HALT, 0 );
+ if ( result == -1 ) {
+ errorStream_ << "RtApiOss::stopStream: system error stopping callback procedure on device (" << stream_.device[0] << ").";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ handle->triggered = false;
+ }
+
+ if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && handle->id[0] != handle->id[1] ) ) {
+ result = ioctl( handle->id[1], SNDCTL_DSP_HALT, 0 );
+ if ( result == -1 ) {
+ errorStream_ << "RtApiOss::stopStream: system error stopping input callback procedure on device (" << stream_.device[0] << ").";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+
+ unlock:
+ stream_.state = STREAM_STOPPED;
+ MUTEX_UNLOCK( &stream_.mutex );
+
+ if ( result != -1 ) return;
+ error( RtAudioError::SYSTEM_ERROR );
+}
+
+void RtApiOss :: abortStream()
+{
+ verifyStream();
+ if ( stream_.state == STREAM_STOPPED ) {
+ errorText_ = "RtApiOss::abortStream(): the stream is already stopped!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ MUTEX_LOCK( &stream_.mutex );
+
+ // The state might change while waiting on a mutex.
+ if ( stream_.state == STREAM_STOPPED ) {
+ MUTEX_UNLOCK( &stream_.mutex );
+ return;
+ }
+
+ int result = 0;
+ OssHandle *handle = (OssHandle *) stream_.apiHandle;
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+ result = ioctl( handle->id[0], SNDCTL_DSP_HALT, 0 );
+ if ( result == -1 ) {
+ errorStream_ << "RtApiOss::abortStream: system error stopping callback procedure on device (" << stream_.device[0] << ").";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ handle->triggered = false;
+ }
+
+ if ( stream_.mode == INPUT || ( stream_.mode == DUPLEX && handle->id[0] != handle->id[1] ) ) {
+ result = ioctl( handle->id[1], SNDCTL_DSP_HALT, 0 );
+ if ( result == -1 ) {
+ errorStream_ << "RtApiOss::abortStream: system error stopping input callback procedure on device (" << stream_.device[0] << ").";
+ errorText_ = errorStream_.str();
+ goto unlock;
+ }
+ }
+
+ unlock:
+ stream_.state = STREAM_STOPPED;
+ MUTEX_UNLOCK( &stream_.mutex );
+
+ if ( result != -1 ) return;
+ error( RtAudioError::SYSTEM_ERROR );
+}
+
+void RtApiOss :: callbackEvent()
+{
+ OssHandle *handle = (OssHandle *) stream_.apiHandle;
+ if ( stream_.state == STREAM_STOPPED ) {
+ MUTEX_LOCK( &stream_.mutex );
+ pthread_cond_wait( &handle->runnable, &stream_.mutex );
+ if ( stream_.state != STREAM_RUNNING ) {
+ MUTEX_UNLOCK( &stream_.mutex );
+ return;
+ }
+ MUTEX_UNLOCK( &stream_.mutex );
+ }
+
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApiOss::callbackEvent(): the stream is closed ... this shouldn't happen!";
+ error( RtAudioError::WARNING );
+ return;
+ }
+
+ // Invoke user callback to get fresh output data.
+ int doStopStream = 0;
+ RtAudioCallback callback = (RtAudioCallback) stream_.callbackInfo.callback;
+ double streamTime = getStreamTime();
+ RtAudioStreamStatus status = 0;
+ if ( stream_.mode != INPUT && handle->xrun[0] == true ) {
+ status |= RTAUDIO_OUTPUT_UNDERFLOW;
+ handle->xrun[0] = false;
+ }
+ if ( stream_.mode != OUTPUT && handle->xrun[1] == true ) {
+ status |= RTAUDIO_INPUT_OVERFLOW;
+ handle->xrun[1] = false;
+ }
+ doStopStream = callback( stream_.userBuffer[0], stream_.userBuffer[1],
+ stream_.bufferSize, streamTime, status, stream_.callbackInfo.userData );
+ if ( doStopStream == 2 ) {
+ this->abortStream();
+ return;
+ }
+
+ MUTEX_LOCK( &stream_.mutex );
+
+ // The state might change while waiting on a mutex.
+ if ( stream_.state == STREAM_STOPPED ) goto unlock;
+
+ int result;
+ char *buffer;
+ int samples;
+ RtAudioFormat format;
+
+ if ( stream_.mode == OUTPUT || stream_.mode == DUPLEX ) {
+
+ // Setup parameters and do buffer conversion if necessary.
+ if ( stream_.doConvertBuffer[0] ) {
+ buffer = stream_.deviceBuffer;
+ convertBuffer( buffer, stream_.userBuffer[0], stream_.convertInfo[0] );
+ samples = stream_.bufferSize * stream_.nDeviceChannels[0];
+ format = stream_.deviceFormat[0];
+ }
+ else {
+ buffer = stream_.userBuffer[0];
+ samples = stream_.bufferSize * stream_.nUserChannels[0];
+ format = stream_.userFormat;
+ }
+
+ // Do byte swapping if necessary.
+ if ( stream_.doByteSwap[0] )
+ byteSwapBuffer( buffer, samples, format );
+
+ if ( stream_.mode == DUPLEX && handle->triggered == false ) {
+ int trig = 0;
+ ioctl( handle->id[0], SNDCTL_DSP_SETTRIGGER, &trig );
+ result = write( handle->id[0], buffer, samples * formatBytes(format) );
+ trig = PCM_ENABLE_INPUT|PCM_ENABLE_OUTPUT;
+ ioctl( handle->id[0], SNDCTL_DSP_SETTRIGGER, &trig );
+ handle->triggered = true;
+ }
+ else
+ // Write samples to device.
+ result = write( handle->id[0], buffer, samples * formatBytes(format) );
+
+ if ( result == -1 ) {
+ // We'll assume this is an underrun, though there isn't a
+ // specific means for determining that.
+ handle->xrun[0] = true;
+ errorText_ = "RtApiOss::callbackEvent: audio write error.";
+ error( RtAudioError::WARNING );
+ // Continue on to input section.
+ }
+ }
+
+ if ( stream_.mode == INPUT || stream_.mode == DUPLEX ) {
+
+ // Setup parameters.
+ if ( stream_.doConvertBuffer[1] ) {
+ buffer = stream_.deviceBuffer;
+ samples = stream_.bufferSize * stream_.nDeviceChannels[1];
+ format = stream_.deviceFormat[1];
+ }
+ else {
+ buffer = stream_.userBuffer[1];
+ samples = stream_.bufferSize * stream_.nUserChannels[1];
+ format = stream_.userFormat;
+ }
+
+ // Read samples from device.
+ result = read( handle->id[1], buffer, samples * formatBytes(format) );
+
+ if ( result == -1 ) {
+ // We'll assume this is an overrun, though there isn't a
+ // specific means for determining that.
+ handle->xrun[1] = true;
+ errorText_ = "RtApiOss::callbackEvent: audio read error.";
+ error( RtAudioError::WARNING );
+ goto unlock;
+ }
+
+ // Do byte swapping if necessary.
+ if ( stream_.doByteSwap[1] )
+ byteSwapBuffer( buffer, samples, format );
+
+ // Do buffer conversion if necessary.
+ if ( stream_.doConvertBuffer[1] )
+ convertBuffer( stream_.userBuffer[1], stream_.deviceBuffer, stream_.convertInfo[1] );
+ }
+
+ unlock:
+ MUTEX_UNLOCK( &stream_.mutex );
+
+ RtApi::tickStreamTime();
+ if ( doStopStream == 1 ) this->stopStream();
+}
+
+static void *ossCallbackHandler( void *ptr )
+{
+ CallbackInfo *info = (CallbackInfo *) ptr;
+ RtApiOss *object = (RtApiOss *) info->object;
+ bool *isRunning = &info->isRunning;
+
+#ifdef SCHED_RR // Undefined with some OSes (e.g. NetBSD 1.6.x with GNU Pthread)
+ if (info->doRealtime) {
+ std::cerr << "RtAudio oss: " <<
+ (sched_getscheduler(0) == SCHED_RR ? "" : "_NOT_ ") <<
+ "running realtime scheduling" << std::endl;
+ }
+#endif
+
+ while ( *isRunning == true ) {
+ pthread_testcancel();
+ object->callbackEvent();
+ }
+
+ pthread_exit( NULL );
+}
+
+//******************** End of __LINUX_OSS__ *********************//
+#endif
+
+
+// *************************************************** //
+//
+// Protected common (OS-independent) RtAudio methods.
+//
+// *************************************************** //
+
+// This method can be modified to control the behavior of error
+// message printing.
+void RtApi :: error( RtAudioError::Type type )
+{
+ errorStream_.str(""); // clear the ostringstream
+
+ RtAudioErrorCallback errorCallback = (RtAudioErrorCallback) stream_.callbackInfo.errorCallback;
+ if ( errorCallback ) {
+ // abortStream() can generate new error messages. Ignore them. Just keep original one.
+
+ if ( firstErrorOccurred_ )
+ return;
+
+ firstErrorOccurred_ = true;
+ const std::string errorMessage = errorText_;
+
+ if ( type != RtAudioError::WARNING && stream_.state != STREAM_STOPPED) {
+ stream_.callbackInfo.isRunning = false; // exit from the thread
+ abortStream();
+ }
+
+ errorCallback( type, errorMessage );
+ firstErrorOccurred_ = false;
+ return;
+ }
+
+ if ( type == RtAudioError::WARNING && showWarnings_ == true )
+ std::cerr << '\n' << errorText_ << "\n\n";
+ else if ( type != RtAudioError::WARNING )
+ throw( RtAudioError( errorText_, type ) );
+}
+
+void RtApi :: verifyStream()
+{
+ if ( stream_.state == STREAM_CLOSED ) {
+ errorText_ = "RtApi:: a stream is not open!";
+ error( RtAudioError::INVALID_USE );
+ }
+}
+
+void RtApi :: clearStreamInfo()
+{
+ stream_.mode = UNINITIALIZED;
+ stream_.state = STREAM_CLOSED;
+ stream_.sampleRate = 0;
+ stream_.bufferSize = 0;
+ stream_.nBuffers = 0;
+ stream_.userFormat = 0;
+ stream_.userInterleaved = true;
+ stream_.streamTime = 0.0;
+ stream_.apiHandle = 0;
+ stream_.deviceBuffer = 0;
+ stream_.callbackInfo.callback = 0;
+ stream_.callbackInfo.userData = 0;
+ stream_.callbackInfo.isRunning = false;
+ stream_.callbackInfo.errorCallback = 0;
+ for ( int i=0; i<2; i++ ) {
+ stream_.device[i] = 11111;
+ stream_.doConvertBuffer[i] = false;
+ stream_.deviceInterleaved[i] = true;
+ stream_.doByteSwap[i] = false;
+ stream_.nUserChannels[i] = 0;
+ stream_.nDeviceChannels[i] = 0;
+ stream_.channelOffset[i] = 0;
+ stream_.deviceFormat[i] = 0;
+ stream_.latency[i] = 0;
+ stream_.userBuffer[i] = 0;
+ stream_.convertInfo[i].channels = 0;
+ stream_.convertInfo[i].inJump = 0;
+ stream_.convertInfo[i].outJump = 0;
+ stream_.convertInfo[i].inFormat = 0;
+ stream_.convertInfo[i].outFormat = 0;
+ stream_.convertInfo[i].inOffset.clear();
+ stream_.convertInfo[i].outOffset.clear();
+ }
+}
+
+unsigned int RtApi :: formatBytes( RtAudioFormat format )
+{
+ if ( format == RTAUDIO_SINT16 )
+ return 2;
+ else if ( format == RTAUDIO_SINT32 || format == RTAUDIO_FLOAT32 )
+ return 4;
+ else if ( format == RTAUDIO_FLOAT64 )
+ return 8;
+ else if ( format == RTAUDIO_SINT24 )
+ return 3;
+ else if ( format == RTAUDIO_SINT8 )
+ return 1;
+
+ errorText_ = "RtApi::formatBytes: undefined format.";
+ error( RtAudioError::WARNING );
+
+ return 0;
+}
+
+void RtApi :: setConvertInfo( StreamMode mode, unsigned int firstChannel )
+{
+ if ( mode == INPUT ) { // convert device to user buffer
+ stream_.convertInfo[mode].inJump = stream_.nDeviceChannels[1];
+ stream_.convertInfo[mode].outJump = stream_.nUserChannels[1];
+ stream_.convertInfo[mode].inFormat = stream_.deviceFormat[1];
+ stream_.convertInfo[mode].outFormat = stream_.userFormat;
+ }
+ else { // convert user to device buffer
+ stream_.convertInfo[mode].inJump = stream_.nUserChannels[0];
+ stream_.convertInfo[mode].outJump = stream_.nDeviceChannels[0];
+ stream_.convertInfo[mode].inFormat = stream_.userFormat;
+ stream_.convertInfo[mode].outFormat = stream_.deviceFormat[0];
+ }
+
+ if ( stream_.convertInfo[mode].inJump < stream_.convertInfo[mode].outJump )
+ stream_.convertInfo[mode].channels = stream_.convertInfo[mode].inJump;
+ else
+ stream_.convertInfo[mode].channels = stream_.convertInfo[mode].outJump;
+
+ // Set up the interleave/deinterleave offsets.
+ if ( stream_.deviceInterleaved[mode] != stream_.userInterleaved ) {
+ if ( ( mode == OUTPUT && stream_.deviceInterleaved[mode] ) ||
+ ( mode == INPUT && stream_.userInterleaved ) ) {
+ for ( int k=0; k<stream_.convertInfo[mode].channels; k++ ) {
+ stream_.convertInfo[mode].inOffset.push_back( k * stream_.bufferSize );
+ stream_.convertInfo[mode].outOffset.push_back( k );
+ stream_.convertInfo[mode].inJump = 1;
+ }
+ }
+ else {
+ for ( int k=0; k<stream_.convertInfo[mode].channels; k++ ) {
+ stream_.convertInfo[mode].inOffset.push_back( k );
+ stream_.convertInfo[mode].outOffset.push_back( k * stream_.bufferSize );
+ stream_.convertInfo[mode].outJump = 1;
+ }
+ }
+ }
+ else { // no (de)interleaving
+ if ( stream_.userInterleaved ) {
+ for ( int k=0; k<stream_.convertInfo[mode].channels; k++ ) {
+ stream_.convertInfo[mode].inOffset.push_back( k );
+ stream_.convertInfo[mode].outOffset.push_back( k );
+ }
+ }
+ else {
+ for ( int k=0; k<stream_.convertInfo[mode].channels; k++ ) {
+ stream_.convertInfo[mode].inOffset.push_back( k * stream_.bufferSize );
+ stream_.convertInfo[mode].outOffset.push_back( k * stream_.bufferSize );
+ stream_.convertInfo[mode].inJump = 1;
+ stream_.convertInfo[mode].outJump = 1;
+ }
+ }
+ }
+
+ // Add channel offset.
+ if ( firstChannel > 0 ) {
+ if ( stream_.deviceInterleaved[mode] ) {
+ if ( mode == OUTPUT ) {
+ for ( int k=0; k<stream_.convertInfo[mode].channels; k++ )
+ stream_.convertInfo[mode].outOffset[k] += firstChannel;
+ }
+ else {
+ for ( int k=0; k<stream_.convertInfo[mode].channels; k++ )
+ stream_.convertInfo[mode].inOffset[k] += firstChannel;
+ }
+ }
+ else {
+ if ( mode == OUTPUT ) {
+ for ( int k=0; k<stream_.convertInfo[mode].channels; k++ )
+ stream_.convertInfo[mode].outOffset[k] += ( firstChannel * stream_.bufferSize );
+ }
+ else {
+ for ( int k=0; k<stream_.convertInfo[mode].channels; k++ )
+ stream_.convertInfo[mode].inOffset[k] += ( firstChannel * stream_.bufferSize );
+ }
+ }
+ }
+}
+
+void RtApi :: convertBuffer( char *outBuffer, char *inBuffer, ConvertInfo &info )
+{
+ // This function does format conversion, input/output channel compensation, and
+ // data interleaving/deinterleaving. 24-bit integers are assumed to occupy
+ // the lower three bytes of a 32-bit integer.
+
+ // Clear our device buffer when in/out duplex device channels are different
+ if ( outBuffer == stream_.deviceBuffer && stream_.mode == DUPLEX &&
+ ( stream_.nDeviceChannels[0] < stream_.nDeviceChannels[1] ) )
+ memset( outBuffer, 0, stream_.bufferSize * info.outJump * formatBytes( info.outFormat ) );
+
+ int j;
+ if (info.outFormat == RTAUDIO_FLOAT64) {
+ Float64 scale;
+ Float64 *out = (Float64 *)outBuffer;
+
+ if (info.inFormat == RTAUDIO_SINT8) {
+ signed char *in = (signed char *)inBuffer;
+ scale = 1.0 / 127.5;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Float64) in[info.inOffset[j]];
+ out[info.outOffset[j]] += 0.5;
+ out[info.outOffset[j]] *= scale;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT16) {
+ Int16 *in = (Int16 *)inBuffer;
+ scale = 1.0 / 32767.5;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Float64) in[info.inOffset[j]];
+ out[info.outOffset[j]] += 0.5;
+ out[info.outOffset[j]] *= scale;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT24) {
+ Int24 *in = (Int24 *)inBuffer;
+ scale = 1.0 / 8388607.5;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Float64) (in[info.inOffset[j]].asInt());
+ out[info.outOffset[j]] += 0.5;
+ out[info.outOffset[j]] *= scale;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT32) {
+ Int32 *in = (Int32 *)inBuffer;
+ scale = 1.0 / 2147483647.5;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Float64) in[info.inOffset[j]];
+ out[info.outOffset[j]] += 0.5;
+ out[info.outOffset[j]] *= scale;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_FLOAT32) {
+ Float32 *in = (Float32 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Float64) in[info.inOffset[j]];
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_FLOAT64) {
+ // Channel compensation and/or (de)interleaving only.
+ Float64 *in = (Float64 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = in[info.inOffset[j]];
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ }
+ else if (info.outFormat == RTAUDIO_FLOAT32) {
+ Float32 scale;
+ Float32 *out = (Float32 *)outBuffer;
+
+ if (info.inFormat == RTAUDIO_SINT8) {
+ signed char *in = (signed char *)inBuffer;
+ scale = (Float32) ( 1.0 / 127.5 );
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Float32) in[info.inOffset[j]];
+ out[info.outOffset[j]] += 0.5;
+ out[info.outOffset[j]] *= scale;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT16) {
+ Int16 *in = (Int16 *)inBuffer;
+ scale = (Float32) ( 1.0 / 32767.5 );
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Float32) in[info.inOffset[j]];
+ out[info.outOffset[j]] += 0.5;
+ out[info.outOffset[j]] *= scale;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT24) {
+ Int24 *in = (Int24 *)inBuffer;
+ scale = (Float32) ( 1.0 / 8388607.5 );
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Float32) (in[info.inOffset[j]].asInt());
+ out[info.outOffset[j]] += 0.5;
+ out[info.outOffset[j]] *= scale;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT32) {
+ Int32 *in = (Int32 *)inBuffer;
+ scale = (Float32) ( 1.0 / 2147483647.5 );
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Float32) in[info.inOffset[j]];
+ out[info.outOffset[j]] += 0.5;
+ out[info.outOffset[j]] *= scale;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_FLOAT32) {
+ // Channel compensation and/or (de)interleaving only.
+ Float32 *in = (Float32 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = in[info.inOffset[j]];
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_FLOAT64) {
+ Float64 *in = (Float64 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Float32) in[info.inOffset[j]];
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ }
+ else if (info.outFormat == RTAUDIO_SINT32) {
+ Int32 *out = (Int32 *)outBuffer;
+ if (info.inFormat == RTAUDIO_SINT8) {
+ signed char *in = (signed char *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int32) in[info.inOffset[j]];
+ out[info.outOffset[j]] <<= 24;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT16) {
+ Int16 *in = (Int16 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int32) in[info.inOffset[j]];
+ out[info.outOffset[j]] <<= 16;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT24) {
+ Int24 *in = (Int24 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int32) in[info.inOffset[j]].asInt();
+ out[info.outOffset[j]] <<= 8;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT32) {
+ // Channel compensation and/or (de)interleaving only.
+ Int32 *in = (Int32 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = in[info.inOffset[j]];
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_FLOAT32) {
+ Float32 *in = (Float32 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] * 2147483647.5 - 0.5);
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_FLOAT64) {
+ Float64 *in = (Float64 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] * 2147483647.5 - 0.5);
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ }
+ else if (info.outFormat == RTAUDIO_SINT24) {
+ Int24 *out = (Int24 *)outBuffer;
+ if (info.inFormat == RTAUDIO_SINT8) {
+ signed char *in = (signed char *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] << 16);
+ //out[info.outOffset[j]] <<= 16;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT16) {
+ Int16 *in = (Int16 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] << 8);
+ //out[info.outOffset[j]] <<= 8;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT24) {
+ // Channel compensation and/or (de)interleaving only.
+ Int24 *in = (Int24 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = in[info.inOffset[j]];
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT32) {
+ Int32 *in = (Int32 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] >> 8);
+ //out[info.outOffset[j]] >>= 8;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_FLOAT32) {
+ Float32 *in = (Float32 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] * 8388607.5 - 0.5);
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_FLOAT64) {
+ Float64 *in = (Float64 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int32) (in[info.inOffset[j]] * 8388607.5 - 0.5);
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ }
+ else if (info.outFormat == RTAUDIO_SINT16) {
+ Int16 *out = (Int16 *)outBuffer;
+ if (info.inFormat == RTAUDIO_SINT8) {
+ signed char *in = (signed char *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int16) in[info.inOffset[j]];
+ out[info.outOffset[j]] <<= 8;
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT16) {
+ // Channel compensation and/or (de)interleaving only.
+ Int16 *in = (Int16 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = in[info.inOffset[j]];
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT24) {
+ Int24 *in = (Int24 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int16) (in[info.inOffset[j]].asInt() >> 8);
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT32) {
+ Int32 *in = (Int32 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int16) ((in[info.inOffset[j]] >> 16) & 0x0000ffff);
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_FLOAT32) {
+ Float32 *in = (Float32 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int16) (in[info.inOffset[j]] * 32767.5 - 0.5);
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_FLOAT64) {
+ Float64 *in = (Float64 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (Int16) (in[info.inOffset[j]] * 32767.5 - 0.5);
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ }
+ else if (info.outFormat == RTAUDIO_SINT8) {
+ signed char *out = (signed char *)outBuffer;
+ if (info.inFormat == RTAUDIO_SINT8) {
+ // Channel compensation and/or (de)interleaving only.
+ signed char *in = (signed char *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = in[info.inOffset[j]];
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ if (info.inFormat == RTAUDIO_SINT16) {
+ Int16 *in = (Int16 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (signed char) ((in[info.inOffset[j]] >> 8) & 0x00ff);
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT24) {
+ Int24 *in = (Int24 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (signed char) (in[info.inOffset[j]].asInt() >> 16);
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_SINT32) {
+ Int32 *in = (Int32 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (signed char) ((in[info.inOffset[j]] >> 24) & 0x000000ff);
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_FLOAT32) {
+ Float32 *in = (Float32 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (signed char) (in[info.inOffset[j]] * 127.5 - 0.5);
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ else if (info.inFormat == RTAUDIO_FLOAT64) {
+ Float64 *in = (Float64 *)inBuffer;
+ for (unsigned int i=0; i<stream_.bufferSize; i++) {
+ for (j=0; j<info.channels; j++) {
+ out[info.outOffset[j]] = (signed char) (in[info.inOffset[j]] * 127.5 - 0.5);
+ }
+ in += info.inJump;
+ out += info.outJump;
+ }
+ }
+ }
+}
+
+//static inline uint16_t bswap_16(uint16_t x) { return (x>>8) | (x<<8); }
+//static inline uint32_t bswap_32(uint32_t x) { return (bswap_16(x&0xffff)<<16) | (bswap_16(x>>16)); }
+//static inline uint64_t bswap_64(uint64_t x) { return (((unsigned long long)bswap_32(x&0xffffffffull))<<32) | (bswap_32(x>>32)); }
+
+void RtApi :: byteSwapBuffer( char *buffer, unsigned int samples, RtAudioFormat format )
+{
+ char val;
+ char *ptr;
+
+ ptr = buffer;
+ if ( format == RTAUDIO_SINT16 ) {
+ for ( unsigned int i=0; i<samples; i++ ) {
+ // Swap 1st and 2nd bytes.
+ val = *(ptr);
+ *(ptr) = *(ptr+1);
+ *(ptr+1) = val;
+
+ // Increment 2 bytes.
+ ptr += 2;
+ }
+ }
+ else if ( format == RTAUDIO_SINT32 ||
+ format == RTAUDIO_FLOAT32 ) {
+ for ( unsigned int i=0; i<samples; i++ ) {
+ // Swap 1st and 4th bytes.
+ val = *(ptr);
+ *(ptr) = *(ptr+3);
+ *(ptr+3) = val;
+
+ // Swap 2nd and 3rd bytes.
+ ptr += 1;
+ val = *(ptr);
+ *(ptr) = *(ptr+1);
+ *(ptr+1) = val;
+
+ // Increment 3 more bytes.
+ ptr += 3;
+ }
+ }
+ else if ( format == RTAUDIO_SINT24 ) {
+ for ( unsigned int i=0; i<samples; i++ ) {
+ // Swap 1st and 3rd bytes.
+ val = *(ptr);
+ *(ptr) = *(ptr+2);
+ *(ptr+2) = val;
+
+ // Increment 2 more bytes.
+ ptr += 2;
+ }
+ }
+ else if ( format == RTAUDIO_FLOAT64 ) {
+ for ( unsigned int i=0; i<samples; i++ ) {
+ // Swap 1st and 8th bytes
+ val = *(ptr);
+ *(ptr) = *(ptr+7);
+ *(ptr+7) = val;
+
+ // Swap 2nd and 7th bytes
+ ptr += 1;
+ val = *(ptr);
+ *(ptr) = *(ptr+5);
+ *(ptr+5) = val;
+
+ // Swap 3rd and 6th bytes
+ ptr += 1;
+ val = *(ptr);
+ *(ptr) = *(ptr+3);
+ *(ptr+3) = val;
+
+ // Swap 4th and 5th bytes
+ ptr += 1;
+ val = *(ptr);
+ *(ptr) = *(ptr+1);
+ *(ptr+1) = val;
+
+ // Increment 5 more bytes.
+ ptr += 5;
+ }
+ }
+}
+
+ // Indentation settings for Vim and Emacs
+ //
+ // Local Variables:
+ // c-basic-offset: 2
+ // indent-tabs-mode: nil
+ // End:
+ //
+ // vim: et sts=2 sw=2
+
diff --git a/src/rtaudio/RtAudio.h b/src/rtaudio/RtAudio.h
new file mode 100644
index 0000000..17f442b
--- /dev/null
+++ b/src/rtaudio/RtAudio.h
@@ -0,0 +1,1203 @@
+/************************************************************************/
+/*! \class RtAudio
+ \brief Realtime audio i/o C++ classes.
+
+ RtAudio provides a common API (Application Programming Interface)
+ for realtime audio input/output across Linux (native ALSA, Jack,
+ and OSS), Macintosh OS X (CoreAudio and Jack), and Windows
+ (DirectSound, ASIO and WASAPI) operating systems.
+
+ RtAudio GitHub site: https://github.com/thestk/rtaudio
+ RtAudio WWW site: http://www.music.mcgill.ca/~gary/rtaudio/
+
+ RtAudio: realtime audio i/o C++ classes
+ Copyright (c) 2001-2019 Gary P. Scavone
+
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation files
+ (the "Software"), to deal in the Software without restriction,
+ including without limitation the rights to use, copy, modify, merge,
+ publish, distribute, sublicense, and/or sell copies of the Software,
+ and to permit persons to whom the Software is furnished to do so,
+ subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ Any person wishing to distribute modifications to the Software is
+ asked to send the modifications to the original developer so that
+ they can be incorporated into the canonical version. This is,
+ however, not a binding provision of this license.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+ CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+/************************************************************************/
+
+/*!
+ \file RtAudio.h
+ */
+
+#ifndef __RTAUDIO_H
+#define __RTAUDIO_H
+
+#define RTAUDIO_VERSION "5.1.0"
+
+#if defined _WIN32 || defined __CYGWIN__
+ #if defined(RTAUDIO_EXPORT)
+ #define RTAUDIO_DLL_PUBLIC __declspec(dllexport)
+ #else
+ #define RTAUDIO_DLL_PUBLIC
+ #endif
+#else
+ #if __GNUC__ >= 4
+ #define RTAUDIO_DLL_PUBLIC __attribute__( (visibility( "default" )) )
+ #else
+ #define RTAUDIO_DLL_PUBLIC
+ #endif
+#endif
+
+#include <string>
+#include <vector>
+#include <stdexcept>
+#include <iostream>
+
+/*! \typedef typedef unsigned long RtAudioFormat;
+ \brief RtAudio data format type.
+
+ Support for signed integers and floats. Audio data fed to/from an
+ RtAudio stream is assumed to ALWAYS be in host byte order. The
+ internal routines will automatically take care of any necessary
+ byte-swapping between the host format and the soundcard. Thus,
+ endian-ness is not a concern in the following format definitions.
+
+ - \e RTAUDIO_SINT8: 8-bit signed integer.
+ - \e RTAUDIO_SINT16: 16-bit signed integer.
+ - \e RTAUDIO_SINT24: 24-bit signed integer.
+ - \e RTAUDIO_SINT32: 32-bit signed integer.
+ - \e RTAUDIO_FLOAT32: Normalized between plus/minus 1.0.
+ - \e RTAUDIO_FLOAT64: Normalized between plus/minus 1.0.
+*/
+typedef unsigned long RtAudioFormat;
+static const RtAudioFormat RTAUDIO_SINT8 = 0x1; // 8-bit signed integer.
+static const RtAudioFormat RTAUDIO_SINT16 = 0x2; // 16-bit signed integer.
+static const RtAudioFormat RTAUDIO_SINT24 = 0x4; // 24-bit signed integer.
+static const RtAudioFormat RTAUDIO_SINT32 = 0x8; // 32-bit signed integer.
+static const RtAudioFormat RTAUDIO_FLOAT32 = 0x10; // Normalized between plus/minus 1.0.
+static const RtAudioFormat RTAUDIO_FLOAT64 = 0x20; // Normalized between plus/minus 1.0.
+
+/*! \typedef typedef unsigned long RtAudioStreamFlags;
+ \brief RtAudio stream option flags.
+
+ The following flags can be OR'ed together to allow a client to
+ make changes to the default stream behavior:
+
+ - \e RTAUDIO_NONINTERLEAVED: Use non-interleaved buffers (default = interleaved).
+ - \e RTAUDIO_MINIMIZE_LATENCY: Attempt to set stream parameters for lowest possible latency.
+ - \e RTAUDIO_HOG_DEVICE: Attempt grab device for exclusive use.
+ - \e RTAUDIO_ALSA_USE_DEFAULT: Use the "default" PCM device (ALSA only).
+ - \e RTAUDIO_JACK_DONT_CONNECT: Do not automatically connect ports (JACK only).
+
+ By default, RtAudio streams pass and receive audio data from the
+ client in an interleaved format. By passing the
+ RTAUDIO_NONINTERLEAVED flag to the openStream() function, audio
+ data will instead be presented in non-interleaved buffers. In
+ this case, each buffer argument in the RtAudioCallback function
+ will point to a single array of data, with \c nFrames samples for
+ each channel concatenated back-to-back. For example, the first
+ sample of data for the second channel would be located at index \c
+ nFrames (assuming the \c buffer pointer was recast to the correct
+ data type for the stream).
+
+ Certain audio APIs offer a number of parameters that influence the
+ I/O latency of a stream. By default, RtAudio will attempt to set
+ these parameters internally for robust (glitch-free) performance
+ (though some APIs, like Windows DirectSound, make this difficult).
+ By passing the RTAUDIO_MINIMIZE_LATENCY flag to the openStream()
+ function, internal stream settings will be influenced in an attempt
+ to minimize stream latency, though possibly at the expense of stream
+ performance.
+
+ If the RTAUDIO_HOG_DEVICE flag is set, RtAudio will attempt to
+ open the input and/or output stream device(s) for exclusive use.
+ Note that this is not possible with all supported audio APIs.
+
+ If the RTAUDIO_SCHEDULE_REALTIME flag is set, RtAudio will attempt
+ to select realtime scheduling (round-robin) for the callback thread.
+
+ If the RTAUDIO_ALSA_USE_DEFAULT flag is set, RtAudio will attempt to
+ open the "default" PCM device when using the ALSA API. Note that this
+ will override any specified input or output device id.
+
+ If the RTAUDIO_JACK_DONT_CONNECT flag is set, RtAudio will not attempt
+ to automatically connect the ports of the client to the audio device.
+*/
+typedef unsigned int RtAudioStreamFlags;
+static const RtAudioStreamFlags RTAUDIO_NONINTERLEAVED = 0x1; // Use non-interleaved buffers (default = interleaved).
+static const RtAudioStreamFlags RTAUDIO_MINIMIZE_LATENCY = 0x2; // Attempt to set stream parameters for lowest possible latency.
+static const RtAudioStreamFlags RTAUDIO_HOG_DEVICE = 0x4; // Attempt grab device and prevent use by others.
+static const RtAudioStreamFlags RTAUDIO_SCHEDULE_REALTIME = 0x8; // Try to select realtime scheduling for callback thread.
+static const RtAudioStreamFlags RTAUDIO_ALSA_USE_DEFAULT = 0x10; // Use the "default" PCM device (ALSA only).
+static const RtAudioStreamFlags RTAUDIO_JACK_DONT_CONNECT = 0x20; // Do not automatically connect ports (JACK only).
+
+/*! \typedef typedef unsigned long RtAudioStreamStatus;
+ \brief RtAudio stream status (over- or underflow) flags.
+
+ Notification of a stream over- or underflow is indicated by a
+ non-zero stream \c status argument in the RtAudioCallback function.
+ The stream status can be one of the following two options,
+ depending on whether the stream is open for output and/or input:
+
+ - \e RTAUDIO_INPUT_OVERFLOW: Input data was discarded because of an overflow condition at the driver.
+ - \e RTAUDIO_OUTPUT_UNDERFLOW: The output buffer ran low, likely producing a break in the output sound.
+*/
+typedef unsigned int RtAudioStreamStatus;
+static const RtAudioStreamStatus RTAUDIO_INPUT_OVERFLOW = 0x1; // Input data was discarded because of an overflow condition at the driver.
+static const RtAudioStreamStatus RTAUDIO_OUTPUT_UNDERFLOW = 0x2; // The output buffer ran low, likely causing a gap in the output sound.
+
+//! RtAudio callback function prototype.
+/*!
+ All RtAudio clients must create a function of type RtAudioCallback
+ to read and/or write data from/to the audio stream. When the
+ underlying audio system is ready for new input or output data, this
+ function will be invoked.
+
+ \param outputBuffer For output (or duplex) streams, the client
+ should write \c nFrames of audio sample frames into this
+ buffer. This argument should be recast to the datatype
+ specified when the stream was opened. For input-only
+ streams, this argument will be NULL.
+
+ \param inputBuffer For input (or duplex) streams, this buffer will
+ hold \c nFrames of input audio sample frames. This
+ argument should be recast to the datatype specified when the
+ stream was opened. For output-only streams, this argument
+ will be NULL.
+
+ \param nFrames The number of sample frames of input or output
+ data in the buffers. The actual buffer size in bytes is
+ dependent on the data type and number of channels in use.
+
+ \param streamTime The number of seconds that have elapsed since the
+ stream was started.
+
+ \param status If non-zero, this argument indicates a data overflow
+ or underflow condition for the stream. The particular
+ condition can be determined by comparison with the
+ RtAudioStreamStatus flags.
+
+ \param userData A pointer to optional data provided by the client
+ when opening the stream (default = NULL).
+
+ \return
+ To continue normal stream operation, the RtAudioCallback function
+ should return a value of zero. To stop the stream and drain the
+ output buffer, the function should return a value of one. To abort
+ the stream immediately, the client should return a value of two.
+ */
+typedef int (*RtAudioCallback)( void *outputBuffer, void *inputBuffer,
+ unsigned int nFrames,
+ double streamTime,
+ RtAudioStreamStatus status,
+ void *userData );
+
+/************************************************************************/
+/*! \class RtAudioError
+ \brief Exception handling class for RtAudio.
+
+ The RtAudioError class is quite simple but it does allow errors to be
+ "caught" by RtAudioError::Type. See the RtAudio documentation to know
+ which methods can throw an RtAudioError.
+*/
+/************************************************************************/
+
+class RTAUDIO_DLL_PUBLIC RtAudioError : public std::runtime_error
+{
+ public:
+ //! Defined RtAudioError types.
+ enum Type {
+ WARNING, /*!< A non-critical error. */
+ DEBUG_WARNING, /*!< A non-critical error which might be useful for debugging. */
+ UNSPECIFIED, /*!< The default, unspecified error type. */
+ NO_DEVICES_FOUND, /*!< No devices found on system. */
+ INVALID_DEVICE, /*!< An invalid device ID was specified. */
+ MEMORY_ERROR, /*!< An error occured during memory allocation. */
+ INVALID_PARAMETER, /*!< An invalid parameter was specified to a function. */
+ INVALID_USE, /*!< The function was called incorrectly. */
+ DRIVER_ERROR, /*!< A system driver error occured. */
+ SYSTEM_ERROR, /*!< A system error occured. */
+ THREAD_ERROR /*!< A thread error occured. */
+ };
+
+ //! The constructor.
+ RtAudioError( const std::string& message,
+ Type type = RtAudioError::UNSPECIFIED )
+ : std::runtime_error(message), type_(type) {}
+
+ //! Prints thrown error message to stderr.
+ virtual void printMessage( void ) const
+ { std::cerr << '\n' << what() << "\n\n"; }
+
+ //! Returns the thrown error message type.
+ virtual const Type& getType(void) const { return type_; }
+
+ //! Returns the thrown error message string.
+ virtual const std::string getMessage(void) const
+ { return std::string(what()); }
+
+ protected:
+ Type type_;
+};
+
+//! RtAudio error callback function prototype.
+/*!
+ \param type Type of error.
+ \param errorText Error description.
+ */
+typedef void (*RtAudioErrorCallback)( RtAudioError::Type type, const std::string &errorText );
+
+// **************************************************************** //
+//
+// RtAudio class declaration.
+//
+// RtAudio is a "controller" used to select an available audio i/o
+// interface. It presents a common API for the user to call but all
+// functionality is implemented by the class RtApi and its
+// subclasses. RtAudio creates an instance of an RtApi subclass
+// based on the user's API choice. If no choice is made, RtAudio
+// attempts to make a "logical" API selection.
+//
+// **************************************************************** //
+
+class RtApi;
+
+class RTAUDIO_DLL_PUBLIC RtAudio
+{
+ public:
+
+ //! Audio API specifier arguments.
+ enum Api {
+ UNSPECIFIED, /*!< Search for a working compiled API. */
+ LINUX_ALSA, /*!< The Advanced Linux Sound Architecture API. */
+ LINUX_PULSE, /*!< The Linux PulseAudio API. */
+ LINUX_OSS, /*!< The Linux Open Sound System API. */
+ UNIX_JACK, /*!< The Jack Low-Latency Audio Server API. */
+ MACOSX_CORE, /*!< Macintosh OS-X Core Audio API. */
+ WINDOWS_WASAPI, /*!< The Microsoft WASAPI API. */
+ WINDOWS_ASIO, /*!< The Steinberg Audio Stream I/O API. */
+ WINDOWS_DS, /*!< The Microsoft DirectSound API. */
+ RTAUDIO_DUMMY, /*!< A compilable but non-functional API. */
+ NUM_APIS /*!< Number of values in this enum. */
+ };
+
+ //! The public device information structure for returning queried values.
+ struct DeviceInfo {
+ bool probed; /*!< true if the device capabilities were successfully probed. */
+ std::string name; /*!< Character string device identifier. */
+ unsigned int outputChannels; /*!< Maximum output channels supported by device. */
+ unsigned int inputChannels; /*!< Maximum input channels supported by device. */
+ unsigned int duplexChannels; /*!< Maximum simultaneous input/output channels supported by device. */
+ bool isDefaultOutput; /*!< true if this is the default output device. */
+ bool isDefaultInput; /*!< true if this is the default input device. */
+ std::vector<unsigned int> sampleRates; /*!< Supported sample rates (queried from list of standard rates). */
+ unsigned int preferredSampleRate; /*!< Preferred sample rate, e.g. for WASAPI the system sample rate. */
+ RtAudioFormat nativeFormats; /*!< Bit mask of supported data formats. */
+
+ // Default constructor.
+ DeviceInfo()
+ :probed(false), outputChannels(0), inputChannels(0), duplexChannels(0),
+ isDefaultOutput(false), isDefaultInput(false), preferredSampleRate(0), nativeFormats(0) {}
+ };
+
+ //! The structure for specifying input or ouput stream parameters.
+ struct StreamParameters {
+ unsigned int deviceId; /*!< Device index (0 to getDeviceCount() - 1). */
+ unsigned int nChannels; /*!< Number of channels. */
+ unsigned int firstChannel; /*!< First channel index on device (default = 0). */
+
+ // Default constructor.
+ StreamParameters()
+ : deviceId(0), nChannels(0), firstChannel(0) {}
+ };
+
+ //! The structure for specifying stream options.
+ /*!
+ The following flags can be OR'ed together to allow a client to
+ make changes to the default stream behavior:
+
+ - \e RTAUDIO_NONINTERLEAVED: Use non-interleaved buffers (default = interleaved).
+ - \e RTAUDIO_MINIMIZE_LATENCY: Attempt to set stream parameters for lowest possible latency.
+ - \e RTAUDIO_HOG_DEVICE: Attempt grab device for exclusive use.
+ - \e RTAUDIO_SCHEDULE_REALTIME: Attempt to select realtime scheduling for callback thread.
+ - \e RTAUDIO_ALSA_USE_DEFAULT: Use the "default" PCM device (ALSA only).
+
+ By default, RtAudio streams pass and receive audio data from the
+ client in an interleaved format. By passing the
+ RTAUDIO_NONINTERLEAVED flag to the openStream() function, audio
+ data will instead be presented in non-interleaved buffers. In
+ this case, each buffer argument in the RtAudioCallback function
+ will point to a single array of data, with \c nFrames samples for
+ each channel concatenated back-to-back. For example, the first
+ sample of data for the second channel would be located at index \c
+ nFrames (assuming the \c buffer pointer was recast to the correct
+ data type for the stream).
+
+ Certain audio APIs offer a number of parameters that influence the
+ I/O latency of a stream. By default, RtAudio will attempt to set
+ these parameters internally for robust (glitch-free) performance
+ (though some APIs, like Windows DirectSound, make this difficult).
+ By passing the RTAUDIO_MINIMIZE_LATENCY flag to the openStream()
+ function, internal stream settings will be influenced in an attempt
+ to minimize stream latency, though possibly at the expense of stream
+ performance.
+
+ If the RTAUDIO_HOG_DEVICE flag is set, RtAudio will attempt to
+ open the input and/or output stream device(s) for exclusive use.
+ Note that this is not possible with all supported audio APIs.
+
+ If the RTAUDIO_SCHEDULE_REALTIME flag is set, RtAudio will attempt
+ to select realtime scheduling (round-robin) for the callback thread.
+ The \c priority parameter will only be used if the RTAUDIO_SCHEDULE_REALTIME
+ flag is set. It defines the thread's realtime priority.
+
+ If the RTAUDIO_ALSA_USE_DEFAULT flag is set, RtAudio will attempt to
+ open the "default" PCM device when using the ALSA API. Note that this
+ will override any specified input or output device id.
+
+ The \c numberOfBuffers parameter can be used to control stream
+ latency in the Windows DirectSound, Linux OSS, and Linux Alsa APIs
+ only. A value of two is usually the smallest allowed. Larger
+ numbers can potentially result in more robust stream performance,
+ though likely at the cost of stream latency. The value set by the
+ user is replaced during execution of the RtAudio::openStream()
+ function by the value actually used by the system.
+
+ The \c streamName parameter can be used to set the client name
+ when using the Jack API. By default, the client name is set to
+ RtApiJack. However, if you wish to create multiple instances of
+ RtAudio with Jack, each instance must have a unique client name.
+ */
+ struct StreamOptions {
+ RtAudioStreamFlags flags; /*!< A bit-mask of stream flags (RTAUDIO_NONINTERLEAVED, RTAUDIO_MINIMIZE_LATENCY, RTAUDIO_HOG_DEVICE, RTAUDIO_ALSA_USE_DEFAULT). */
+ unsigned int numberOfBuffers; /*!< Number of stream buffers. */
+ std::string streamName; /*!< A stream name (currently used only in Jack). */
+ int priority; /*!< Scheduling priority of callback thread (only used with flag RTAUDIO_SCHEDULE_REALTIME). */
+
+ // Default constructor.
+ StreamOptions()
+ : flags(0), numberOfBuffers(0), priority(0) {}
+ };
+
+ //! A static function to determine the current RtAudio version.
+ static std::string getVersion( void );
+
+ //! A static function to determine the available compiled audio APIs.
+ /*!
+ The values returned in the std::vector can be compared against
+ the enumerated list values. Note that there can be more than one
+ API compiled for certain operating systems.
+ */
+ static void getCompiledApi( std::vector<RtAudio::Api> &apis );
+
+ //! Return the name of a specified compiled audio API.
+ /*!
+ This obtains a short lower-case name used for identification purposes.
+ This value is guaranteed to remain identical across library versions.
+ If the API is unknown, this function will return the empty string.
+ */
+ static std::string getApiName( RtAudio::Api api );
+
+ //! Return the display name of a specified compiled audio API.
+ /*!
+ This obtains a long name used for display purposes.
+ If the API is unknown, this function will return the empty string.
+ */
+ static std::string getApiDisplayName( RtAudio::Api api );
+
+ //! Return the compiled audio API having the given name.
+ /*!
+ A case insensitive comparison will check the specified name
+ against the list of compiled APIs, and return the one which
+ matches. On failure, the function returns UNSPECIFIED.
+ */
+ static RtAudio::Api getCompiledApiByName( const std::string &name );
+
+ //! The class constructor.
+ /*!
+ The constructor performs minor initialization tasks. An exception
+ can be thrown if no API support is compiled.
+
+ If no API argument is specified and multiple API support has been
+ compiled, the default order of use is JACK, ALSA, OSS (Linux
+ systems) and ASIO, DS (Windows systems).
+ */
+ RtAudio( RtAudio::Api api=UNSPECIFIED );
+
+ //! The destructor.
+ /*!
+ If a stream is running or open, it will be stopped and closed
+ automatically.
+ */
+ ~RtAudio();
+
+ //! Returns the audio API specifier for the current instance of RtAudio.
+ RtAudio::Api getCurrentApi( void );
+
+ //! A public function that queries for the number of audio devices available.
+ /*!
+ This function performs a system query of available devices each time it
+ is called, thus supporting devices connected \e after instantiation. If
+ a system error occurs during processing, a warning will be issued.
+ */
+ unsigned int getDeviceCount( void );
+
+ //! Return an RtAudio::DeviceInfo structure for a specified device number.
+ /*!
+
+ Any device integer between 0 and getDeviceCount() - 1 is valid.
+ If an invalid argument is provided, an RtAudioError (type = INVALID_USE)
+ will be thrown. If a device is busy or otherwise unavailable, the
+ structure member "probed" will have a value of "false" and all
+ other members are undefined. If the specified device is the
+ current default input or output device, the corresponding
+ "isDefault" member will have a value of "true".
+ */
+ RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
+
+ //! A function that returns the index of the default output device.
+ /*!
+ If the underlying audio API does not provide a "default
+ device", or if no devices are available, the return value will be
+ 0. Note that this is a valid device identifier and it is the
+ client's responsibility to verify that a device is available
+ before attempting to open a stream.
+ */
+ unsigned int getDefaultOutputDevice( void );
+
+ //! A function that returns the index of the default input device.
+ /*!
+ If the underlying audio API does not provide a "default
+ device", or if no devices are available, the return value will be
+ 0. Note that this is a valid device identifier and it is the
+ client's responsibility to verify that a device is available
+ before attempting to open a stream.
+ */
+ unsigned int getDefaultInputDevice( void );
+
+ //! A public function for opening a stream with the specified parameters.
+ /*!
+ An RtAudioError (type = SYSTEM_ERROR) is thrown if a stream cannot be
+ opened with the specified parameters or an error occurs during
+ processing. An RtAudioError (type = INVALID_USE) is thrown if any
+ invalid device ID or channel number parameters are specified.
+
+ \param outputParameters Specifies output stream parameters to use
+ when opening a stream, including a device ID, number of channels,
+ and starting channel number. For input-only streams, this
+ argument should be NULL. The device ID is an index value between
+ 0 and getDeviceCount() - 1.
+ \param inputParameters Specifies input stream parameters to use
+ when opening a stream, including a device ID, number of channels,
+ and starting channel number. For output-only streams, this
+ argument should be NULL. The device ID is an index value between
+ 0 and getDeviceCount() - 1.
+ \param format An RtAudioFormat specifying the desired sample data format.
+ \param sampleRate The desired sample rate (sample frames per second).
+ \param *bufferFrames A pointer to a value indicating the desired
+ internal buffer size in sample frames. The actual value
+ used by the device is returned via the same pointer. A
+ value of zero can be specified, in which case the lowest
+ allowable value is determined.
+ \param callback A client-defined function that will be invoked
+ when input data is available and/or output data is needed.
+ \param userData An optional pointer to data that can be accessed
+ from within the callback function.
+ \param options An optional pointer to a structure containing various
+ global stream options, including a list of OR'ed RtAudioStreamFlags
+ and a suggested number of stream buffers that can be used to
+ control stream latency. More buffers typically result in more
+ robust performance, though at a cost of greater latency. If a
+ value of zero is specified, a system-specific median value is
+ chosen. If the RTAUDIO_MINIMIZE_LATENCY flag bit is set, the
+ lowest allowable value is used. The actual value used is
+ returned via the structure argument. The parameter is API dependent.
+ \param errorCallback A client-defined function that will be invoked
+ when an error has occured.
+ */
+ void openStream( RtAudio::StreamParameters *outputParameters,
+ RtAudio::StreamParameters *inputParameters,
+ RtAudioFormat format, unsigned int sampleRate,
+ unsigned int *bufferFrames, RtAudioCallback callback,
+ void *userData = NULL, RtAudio::StreamOptions *options = NULL, RtAudioErrorCallback errorCallback = NULL );
+
+ //! A function that closes a stream and frees any associated stream memory.
+ /*!
+ If a stream is not open, this function issues a warning and
+ returns (no exception is thrown).
+ */
+ void closeStream( void );
+
+ //! A function that starts a stream.
+ /*!
+ An RtAudioError (type = SYSTEM_ERROR) is thrown if an error occurs
+ during processing. An RtAudioError (type = INVALID_USE) is thrown if a
+ stream is not open. A warning is issued if the stream is already
+ running.
+ */
+ void startStream( void );
+
+ //! Stop a stream, allowing any samples remaining in the output queue to be played.
+ /*!
+ An RtAudioError (type = SYSTEM_ERROR) is thrown if an error occurs
+ during processing. An RtAudioError (type = INVALID_USE) is thrown if a
+ stream is not open. A warning is issued if the stream is already
+ stopped.
+ */
+ void stopStream( void );
+
+ //! Stop a stream, discarding any samples remaining in the input/output queue.
+ /*!
+ An RtAudioError (type = SYSTEM_ERROR) is thrown if an error occurs
+ during processing. An RtAudioError (type = INVALID_USE) is thrown if a
+ stream is not open. A warning is issued if the stream is already
+ stopped.
+ */
+ void abortStream( void );
+
+ //! Returns true if a stream is open and false if not.
+ bool isStreamOpen( void ) const;
+
+ //! Returns true if the stream is running and false if it is stopped or not open.
+ bool isStreamRunning( void ) const;
+
+ //! Returns the number of elapsed seconds since the stream was started.
+ /*!
+ If a stream is not open, an RtAudioError (type = INVALID_USE) will be thrown.
+ */
+ double getStreamTime( void );
+
+ //! Set the stream time to a time in seconds greater than or equal to 0.0.
+ /*!
+ If a stream is not open, an RtAudioError (type = INVALID_USE) will be thrown.
+ */
+ void setStreamTime( double time );
+
+ //! Returns the internal stream latency in sample frames.
+ /*!
+ The stream latency refers to delay in audio input and/or output
+ caused by internal buffering by the audio system and/or hardware.
+ For duplex streams, the returned value will represent the sum of
+ the input and output latencies. If a stream is not open, an
+ RtAudioError (type = INVALID_USE) will be thrown. If the API does not
+ report latency, the return value will be zero.
+ */
+ long getStreamLatency( void );
+
+ //! Returns actual sample rate in use by the stream.
+ /*!
+ On some systems, the sample rate used may be slightly different
+ than that specified in the stream parameters. If a stream is not
+ open, an RtAudioError (type = INVALID_USE) will be thrown.
+ */
+ unsigned int getStreamSampleRate( void );
+
+ //! Specify whether warning messages should be printed to stderr.
+ void showWarnings( bool value = true );
+
+ protected:
+
+ void openRtApi( RtAudio::Api api );
+ RtApi *rtapi_;
+};
+
+// Operating system dependent thread functionality.
+#if defined(__WINDOWS_DS__) || defined(__WINDOWS_ASIO__) || defined(__WINDOWS_WASAPI__)
+
+ #ifndef NOMINMAX
+ #define NOMINMAX
+ #endif
+ #include <windows.h>
+ #include <process.h>
+ #include <stdint.h>
+
+ typedef uintptr_t ThreadHandle;
+ typedef CRITICAL_SECTION StreamMutex;
+
+#elif defined(__LINUX_ALSA__) || defined(__LINUX_PULSE__) || defined(__UNIX_JACK__) || defined(__LINUX_OSS__) || defined(__MACOSX_CORE__)
+ // Using pthread library for various flavors of unix.
+ #include <pthread.h>
+
+ typedef pthread_t ThreadHandle;
+ typedef pthread_mutex_t StreamMutex;
+
+#else // Setup for "dummy" behavior
+
+ #define __RTAUDIO_DUMMY__
+ typedef int ThreadHandle;
+ typedef int StreamMutex;
+
+#endif
+
+// This global structure type is used to pass callback information
+// between the private RtAudio stream structure and global callback
+// handling functions.
+struct CallbackInfo {
+ void *object; // Used as a "this" pointer.
+ ThreadHandle thread;
+ void *callback;
+ void *userData;
+ void *errorCallback;
+ void *apiInfo; // void pointer for API specific callback information
+ bool isRunning;
+ bool doRealtime;
+ int priority;
+
+ // Default constructor.
+ CallbackInfo()
+ :object(0), callback(0), userData(0), errorCallback(0), apiInfo(0), isRunning(false), doRealtime(false), priority(0) {}
+};
+
+// **************************************************************** //
+//
+// RtApi class declaration.
+//
+// Subclasses of RtApi contain all API- and OS-specific code necessary
+// to fully implement the RtAudio API.
+//
+// Note that RtApi is an abstract base class and cannot be
+// explicitly instantiated. The class RtAudio will create an
+// instance of an RtApi subclass (RtApiOss, RtApiAlsa,
+// RtApiJack, RtApiCore, RtApiDs, or RtApiAsio).
+//
+// **************************************************************** //
+
+#pragma pack(push, 1)
+class S24 {
+
+ protected:
+ unsigned char c3[3];
+
+ public:
+ S24() {}
+
+ S24& operator = ( const int& i ) {
+ c3[0] = (i & 0x000000ff);
+ c3[1] = (i & 0x0000ff00) >> 8;
+ c3[2] = (i & 0x00ff0000) >> 16;
+ return *this;
+ }
+
+ S24( const double& d ) { *this = (int) d; }
+ S24( const float& f ) { *this = (int) f; }
+ S24( const signed short& s ) { *this = (int) s; }
+ S24( const char& c ) { *this = (int) c; }
+
+ int asInt() {
+ int i = c3[0] | (c3[1] << 8) | (c3[2] << 16);
+ if (i & 0x800000) i |= ~0xffffff;
+ return i;
+ }
+};
+#pragma pack(pop)
+
+#if defined( HAVE_GETTIMEOFDAY )
+ #include <sys/time.h>
+#endif
+
+#include <sstream>
+
+class RTAUDIO_DLL_PUBLIC RtApi
+{
+public:
+
+ RtApi();
+ virtual ~RtApi();
+ virtual RtAudio::Api getCurrentApi( void ) = 0;
+ virtual unsigned int getDeviceCount( void ) = 0;
+ virtual RtAudio::DeviceInfo getDeviceInfo( unsigned int device ) = 0;
+ virtual unsigned int getDefaultInputDevice( void );
+ virtual unsigned int getDefaultOutputDevice( void );
+ void openStream( RtAudio::StreamParameters *outputParameters,
+ RtAudio::StreamParameters *inputParameters,
+ RtAudioFormat format, unsigned int sampleRate,
+ unsigned int *bufferFrames, RtAudioCallback callback,
+ void *userData, RtAudio::StreamOptions *options,
+ RtAudioErrorCallback errorCallback );
+ virtual void closeStream( void );
+ virtual void startStream( void ) = 0;
+ virtual void stopStream( void ) = 0;
+ virtual void abortStream( void ) = 0;
+ long getStreamLatency( void );
+ unsigned int getStreamSampleRate( void );
+ virtual double getStreamTime( void );
+ virtual void setStreamTime( double time );
+ bool isStreamOpen( void ) const { return stream_.state != STREAM_CLOSED; }
+ bool isStreamRunning( void ) const { return stream_.state == STREAM_RUNNING; }
+ void showWarnings( bool value ) { showWarnings_ = value; }
+
+
+protected:
+
+ static const unsigned int MAX_SAMPLE_RATES;
+ static const unsigned int SAMPLE_RATES[];
+
+ enum { FAILURE, SUCCESS };
+
+ enum StreamState {
+ STREAM_STOPPED,
+ STREAM_STOPPING,
+ STREAM_RUNNING,
+ STREAM_CLOSED = -50
+ };
+
+ enum StreamMode {
+ OUTPUT,
+ INPUT,
+ DUPLEX,
+ UNINITIALIZED = -75
+ };
+
+ // A protected structure used for buffer conversion.
+ struct ConvertInfo {
+ int channels;
+ int inJump, outJump;
+ RtAudioFormat inFormat, outFormat;
+ std::vector<int> inOffset;
+ std::vector<int> outOffset;
+ };
+
+ // A protected structure for audio streams.
+ struct RtApiStream {
+ unsigned int device[2]; // Playback and record, respectively.
+ void *apiHandle; // void pointer for API specific stream handle information
+ StreamMode mode; // OUTPUT, INPUT, or DUPLEX.
+ StreamState state; // STOPPED, RUNNING, or CLOSED
+ char *userBuffer[2]; // Playback and record, respectively.
+ char *deviceBuffer;
+ bool doConvertBuffer[2]; // Playback and record, respectively.
+ bool userInterleaved;
+ bool deviceInterleaved[2]; // Playback and record, respectively.
+ bool doByteSwap[2]; // Playback and record, respectively.
+ unsigned int sampleRate;
+ unsigned int bufferSize;
+ unsigned int nBuffers;
+ unsigned int nUserChannels[2]; // Playback and record, respectively.
+ unsigned int nDeviceChannels[2]; // Playback and record channels, respectively.
+ unsigned int channelOffset[2]; // Playback and record, respectively.
+ unsigned long latency[2]; // Playback and record, respectively.
+ RtAudioFormat userFormat;
+ RtAudioFormat deviceFormat[2]; // Playback and record, respectively.
+ StreamMutex mutex;
+ CallbackInfo callbackInfo;
+ ConvertInfo convertInfo[2];
+ double streamTime; // Number of elapsed seconds since the stream started.
+
+#if defined(HAVE_GETTIMEOFDAY)
+ struct timeval lastTickTimestamp;
+#endif
+
+ RtApiStream()
+ :apiHandle(0), deviceBuffer(0) { device[0] = 11111; device[1] = 11111; }
+ };
+
+ typedef S24 Int24;
+ typedef signed short Int16;
+ typedef signed int Int32;
+ typedef float Float32;
+ typedef double Float64;
+
+ std::ostringstream errorStream_;
+ std::string errorText_;
+ bool showWarnings_;
+ RtApiStream stream_;
+ bool firstErrorOccurred_;
+
+ /*!
+ Protected, api-specific method that attempts to open a device
+ with the given parameters. This function MUST be implemented by
+ all subclasses. If an error is encountered during the probe, a
+ "warning" message is reported and FAILURE is returned. A
+ successful probe is indicated by a return value of SUCCESS.
+ */
+ virtual bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options );
+
+ //! A protected function used to increment the stream time.
+ void tickStreamTime( void );
+
+ //! Protected common method to clear an RtApiStream structure.
+ void clearStreamInfo();
+
+ /*!
+ Protected common method that throws an RtAudioError (type =
+ INVALID_USE) if a stream is not open.
+ */
+ void verifyStream( void );
+
+ //! Protected common error method to allow global control over error handling.
+ void error( RtAudioError::Type type );
+
+ /*!
+ Protected method used to perform format, channel number, and/or interleaving
+ conversions between the user and device buffers.
+ */
+ void convertBuffer( char *outBuffer, char *inBuffer, ConvertInfo &info );
+
+ //! Protected common method used to perform byte-swapping on buffers.
+ void byteSwapBuffer( char *buffer, unsigned int samples, RtAudioFormat format );
+
+ //! Protected common method that returns the number of bytes for a given format.
+ unsigned int formatBytes( RtAudioFormat format );
+
+ //! Protected common method that sets up the parameters for buffer conversion.
+ void setConvertInfo( StreamMode mode, unsigned int firstChannel );
+};
+
+// **************************************************************** //
+//
+// Inline RtAudio definitions.
+//
+// **************************************************************** //
+
+inline RtAudio::Api RtAudio :: getCurrentApi( void ) { return rtapi_->getCurrentApi(); }
+inline unsigned int RtAudio :: getDeviceCount( void ) { return rtapi_->getDeviceCount(); }
+inline RtAudio::DeviceInfo RtAudio :: getDeviceInfo( unsigned int device ) { return rtapi_->getDeviceInfo( device ); }
+inline unsigned int RtAudio :: getDefaultInputDevice( void ) { return rtapi_->getDefaultInputDevice(); }
+inline unsigned int RtAudio :: getDefaultOutputDevice( void ) { return rtapi_->getDefaultOutputDevice(); }
+inline void RtAudio :: closeStream( void ) { return rtapi_->closeStream(); }
+inline void RtAudio :: startStream( void ) { return rtapi_->startStream(); }
+inline void RtAudio :: stopStream( void ) { return rtapi_->stopStream(); }
+inline void RtAudio :: abortStream( void ) { return rtapi_->abortStream(); }
+inline bool RtAudio :: isStreamOpen( void ) const { return rtapi_->isStreamOpen(); }
+inline bool RtAudio :: isStreamRunning( void ) const { return rtapi_->isStreamRunning(); }
+inline long RtAudio :: getStreamLatency( void ) { return rtapi_->getStreamLatency(); }
+inline unsigned int RtAudio :: getStreamSampleRate( void ) { return rtapi_->getStreamSampleRate(); }
+inline double RtAudio :: getStreamTime( void ) { return rtapi_->getStreamTime(); }
+inline void RtAudio :: setStreamTime( double time ) { return rtapi_->setStreamTime( time ); }
+inline void RtAudio :: showWarnings( bool value ) { rtapi_->showWarnings( value ); }
+
+// RtApi Subclass prototypes.
+
+#if defined(__MACOSX_CORE__)
+
+#include <CoreAudio/AudioHardware.h>
+
+class RtApiCore: public RtApi
+{
+public:
+
+ RtApiCore();
+ ~RtApiCore();
+ RtAudio::Api getCurrentApi( void ) { return RtAudio::MACOSX_CORE; }
+ unsigned int getDeviceCount( void );
+ RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
+ unsigned int getDefaultOutputDevice( void );
+ unsigned int getDefaultInputDevice( void );
+ void closeStream( void );
+ void startStream( void );
+ void stopStream( void );
+ void abortStream( void );
+
+ // This function is intended for internal use only. It must be
+ // public because it is called by the internal callback handler,
+ // which is not a member of RtAudio. External use of this function
+ // will most likely produce highly undesireable results!
+ bool callbackEvent( AudioDeviceID deviceId,
+ const AudioBufferList *inBufferList,
+ const AudioBufferList *outBufferList );
+
+ private:
+
+ bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options );
+ static const char* getErrorCode( OSStatus code );
+};
+
+#endif
+
+#if defined(__UNIX_JACK__)
+
+class RtApiJack: public RtApi
+{
+public:
+
+ RtApiJack();
+ ~RtApiJack();
+ RtAudio::Api getCurrentApi( void ) { return RtAudio::UNIX_JACK; }
+ unsigned int getDeviceCount( void );
+ RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
+ void closeStream( void );
+ void startStream( void );
+ void stopStream( void );
+ void abortStream( void );
+
+ // This function is intended for internal use only. It must be
+ // public because it is called by the internal callback handler,
+ // which is not a member of RtAudio. External use of this function
+ // will most likely produce highly undesireable results!
+ bool callbackEvent( unsigned long nframes );
+
+ private:
+
+ bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options );
+
+ bool shouldAutoconnect_;
+};
+
+#endif
+
+#if defined(__WINDOWS_ASIO__)
+
+class RtApiAsio: public RtApi
+{
+public:
+
+ RtApiAsio();
+ ~RtApiAsio();
+ RtAudio::Api getCurrentApi( void ) { return RtAudio::WINDOWS_ASIO; }
+ unsigned int getDeviceCount( void );
+ RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
+ void closeStream( void );
+ void startStream( void );
+ void stopStream( void );
+ void abortStream( void );
+
+ // This function is intended for internal use only. It must be
+ // public because it is called by the internal callback handler,
+ // which is not a member of RtAudio. External use of this function
+ // will most likely produce highly undesireable results!
+ bool callbackEvent( long bufferIndex );
+
+ private:
+
+ std::vector<RtAudio::DeviceInfo> devices_;
+ void saveDeviceInfo( void );
+ bool coInitialized_;
+ bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options );
+};
+
+#endif
+
+#if defined(__WINDOWS_DS__)
+
+class RtApiDs: public RtApi
+{
+public:
+
+ RtApiDs();
+ ~RtApiDs();
+ RtAudio::Api getCurrentApi( void ) { return RtAudio::WINDOWS_DS; }
+ unsigned int getDeviceCount( void );
+ unsigned int getDefaultOutputDevice( void );
+ unsigned int getDefaultInputDevice( void );
+ RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
+ void closeStream( void );
+ void startStream( void );
+ void stopStream( void );
+ void abortStream( void );
+
+ // This function is intended for internal use only. It must be
+ // public because it is called by the internal callback handler,
+ // which is not a member of RtAudio. External use of this function
+ // will most likely produce highly undesireable results!
+ void callbackEvent( void );
+
+ private:
+
+ bool coInitialized_;
+ bool buffersRolling;
+ long duplexPrerollBytes;
+ std::vector<struct DsDevice> dsDevices;
+ bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options );
+};
+
+#endif
+
+#if defined(__WINDOWS_WASAPI__)
+
+struct IMMDeviceEnumerator;
+
+class RtApiWasapi : public RtApi
+{
+public:
+ RtApiWasapi();
+ virtual ~RtApiWasapi();
+
+ RtAudio::Api getCurrentApi( void ) { return RtAudio::WINDOWS_WASAPI; }
+ unsigned int getDeviceCount( void );
+ RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
+ unsigned int getDefaultOutputDevice( void );
+ unsigned int getDefaultInputDevice( void );
+ void closeStream( void );
+ void startStream( void );
+ void stopStream( void );
+ void abortStream( void );
+
+private:
+ bool coInitialized_;
+ IMMDeviceEnumerator* deviceEnumerator_;
+
+ bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int* bufferSize,
+ RtAudio::StreamOptions* options );
+
+ static DWORD WINAPI runWasapiThread( void* wasapiPtr );
+ static DWORD WINAPI stopWasapiThread( void* wasapiPtr );
+ static DWORD WINAPI abortWasapiThread( void* wasapiPtr );
+ void wasapiThread();
+};
+
+#endif
+
+#if defined(__LINUX_ALSA__)
+
+class RtApiAlsa: public RtApi
+{
+public:
+
+ RtApiAlsa();
+ ~RtApiAlsa();
+ RtAudio::Api getCurrentApi() { return RtAudio::LINUX_ALSA; }
+ unsigned int getDeviceCount( void );
+ RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
+ void closeStream( void );
+ void startStream( void );
+ void stopStream( void );
+ void abortStream( void );
+
+ // This function is intended for internal use only. It must be
+ // public because it is called by the internal callback handler,
+ // which is not a member of RtAudio. External use of this function
+ // will most likely produce highly undesireable results!
+ void callbackEvent( void );
+
+ private:
+
+ std::vector<RtAudio::DeviceInfo> devices_;
+ void saveDeviceInfo( void );
+ bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options );
+};
+
+#endif
+
+#if defined(__LINUX_PULSE__)
+
+class RtApiPulse: public RtApi
+{
+public:
+ ~RtApiPulse();
+ RtAudio::Api getCurrentApi() { return RtAudio::LINUX_PULSE; }
+ unsigned int getDeviceCount( void );
+ RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
+ void closeStream( void );
+ void startStream( void );
+ void stopStream( void );
+ void abortStream( void );
+
+ // This function is intended for internal use only. It must be
+ // public because it is called by the internal callback handler,
+ // which is not a member of RtAudio. External use of this function
+ // will most likely produce highly undesireable results!
+ void callbackEvent( void );
+
+ private:
+
+ std::vector<RtAudio::DeviceInfo> devices_;
+ void saveDeviceInfo( void );
+ bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options );
+};
+
+#endif
+
+#if defined(__LINUX_OSS__)
+
+class RtApiOss: public RtApi
+{
+public:
+
+ RtApiOss();
+ ~RtApiOss();
+ RtAudio::Api getCurrentApi() { return RtAudio::LINUX_OSS; }
+ unsigned int getDeviceCount( void );
+ RtAudio::DeviceInfo getDeviceInfo( unsigned int device );
+ void closeStream( void );
+ void startStream( void );
+ void stopStream( void );
+ void abortStream( void );
+
+ // This function is intended for internal use only. It must be
+ // public because it is called by the internal callback handler,
+ // which is not a member of RtAudio. External use of this function
+ // will most likely produce highly undesireable results!
+ void callbackEvent( void );
+
+ private:
+
+ bool probeDeviceOpen( unsigned int device, StreamMode mode, unsigned int channels,
+ unsigned int firstChannel, unsigned int sampleRate,
+ RtAudioFormat format, unsigned int *bufferSize,
+ RtAudio::StreamOptions *options );
+};
+
+#endif
+
+#if defined(__RTAUDIO_DUMMY__)
+
+class RtApiDummy: public RtApi
+{
+public:
+
+ RtApiDummy() { errorText_ = "RtApiDummy: This class provides no functionality."; error( RtAudioError::WARNING ); }
+ RtAudio::Api getCurrentApi( void ) { return RtAudio::RTAUDIO_DUMMY; }
+ unsigned int getDeviceCount( void ) { return 0; }
+ RtAudio::DeviceInfo getDeviceInfo( unsigned int /*device*/ ) { RtAudio::DeviceInfo info; return info; }
+ void closeStream( void ) {}
+ void startStream( void ) {}
+ void stopStream( void ) {}
+ void abortStream( void ) {}
+
+ private:
+
+ bool probeDeviceOpen( unsigned int /*device*/, StreamMode /*mode*/, unsigned int /*channels*/,
+ unsigned int /*firstChannel*/, unsigned int /*sampleRate*/,
+ RtAudioFormat /*format*/, unsigned int * /*bufferSize*/,
+ RtAudio::StreamOptions * /*options*/ ) { return false; }
+};
+
+#endif
+
+#endif
+
+// Indentation settings for Vim and Emacs
+//
+// Local Variables:
+// c-basic-offset: 2
+// indent-tabs-mode: nil
+// End:
+//
+// vim: et sts=2 sw=2
diff --git a/src/rtaudio/RtAudio.os b/src/rtaudio/RtAudio.os
new file mode 100644
index 0000000000000000000000000000000000000000..82494c53fc326b37589644c4dab3e3e13e4cdc6d
GIT binary patch
literal 1493776
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%0AeM8*SxI)DebIL5%A~+DFvB#+(iYn0F(iw
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%0Af?Nw7&t(ngnR5wx#vp3~xbS{<0dzpccLoL~
z)$a^2-I10cO@bh~xs0iW46G?&wV*%}y9iYZQ9qY4r-Xqu11@cfDh-Z2)+yjT0m`hA
zAZcxoZD0aC+X7Lu5Ud6yPz+N8i9A-wlsriNbeIe{+#wEt=-v+2ZTOvmVK+z(h`|KX
z0age#=MY@YeVl5}z|}BcVqjnbn*(wa6DTO4=G1{b3lfk8sWC?cTa@LB3k(c`AYq8J
zn!rjyd=HRPa0o+W+Q2fP08IzUfDB;*5e$zRQ}fdpSi8XTAe|8PeQ^FHn0iEg#=y^|
z!v}IEKbI~aXf_5sQN_q*#Vv9Ldae~0<Wx$=bC(zxu3Q4`<^2V_(UL0=Y&PS|OAHKO
zU{Xx-2>CFGJm+Nw29e89t&j;i@VR$f_EMm#53<ODD-x_2q>j<*G6RDvNQ3Gx1_mY&
z3sR|bIZA;lPezDt2gsqE;Q1;p$dP<Oml+rsD=srIG{bd+SWw+gQlKV3)VgGZbt^A3
zFzf_r5CK^SVlnZ6JOQ!B7IOFuxQ)P70@lTN`!WN=Yq$=Oo0&k`AdMTYMzA7~03*v4
z1_rJx3=GU5pD=(c5>N(V5L|N!misKtc@nNLFxY~MDN8G9(5wW6ZH>gXmn?Y=Q{x~3
zQUlJRpq#<LuW^DKa)9m)Zpgv8kGUZS=RV<v9GLr*8**Uob8g5%x-Ymv2j|XZOvx-`
z(6|aN;y?!MxWd4|<PK^%fCy;L7dPVic9nsFU)+dmVjYAIg3^bfH0VIsAal^cv*08r
z9tS>}4OCUJUIm#53QKV1Dh|2PUI8QusvW@%Wd;wB&&5-uK@=!mL-^@v{46wnE*if8
z&IeB-iCdY1&Y2Y~xC$+r#H~$1$JIh4ZA{hcVdA!?pz~@W;&!GcaB&AyJ~2kf?2Wji
zsfZXOEI>;5-oOnlb#$zU)@R^&1;+}==dh`sKTO;PH(*2U|Ct0q2_Cu_T!Ncf3gl--
z&1(z{`qvm3m_0#b<B*|te#mhfjIP%h7y@8&OmZLvkil~fW}`_v;e+Qg5al41j1|`y
z80tV;LJ+DsnT^^IsudurL5dicU1MNa16K_hT2_I`$AbpXk6mM6I0KRgI}ReR4Uq?>
z3&v;H7#Kdn<dMg{4IqlZhHzhJU=X|x^C83#bBH|H5bf&>3}!HSWJ7EqiopH~xX!>3
z4N?U17ZZpD9Xw}ewg8P!K-&5e4iGJ1dz-H_F!X`6fE*9e0<qi$q6lpHit7vvn?Z^Y
z=0X&CKoo&ZI(wag;RZ+%x=GM=wqTP!U1wnU3sQt`QUJsxQ1mg1-(X;ny}`i13{nIs
zib072oN~ZPUl3##bf)kR6ZgzpNXZA>q=L@Wz>-hK4F-lhkb%0O_(n}WEjJh#`eAZR
z!cvUTLoFpZn2pXN5(G5)fK)PWzrnz;7o^1kWE>>1aWWenM5u-)ACMx(r#BcFUc*&G
z!VQ{yoI%Nl^(F%Y_e}-{X0YQR^3ddCdV_(1QS~MRg8@t)Ip(3s2W*JfO$LSlm?G%h
z3pDwF4avI6z)%X4M>YhSe8B$dzsbNb3#16-FD4KRk$ga-8mP$!Z116)3=C&MT0oA6
zXo2_untZ^PKflSq@Cl>{VJ<`wH2Hu{;<?4ZAbtxP49F%ylMmP=!&?jtHXudlCP9-A
zDEb(~ZZR;#z!X9H!4e|O;8UL&t8XzdwB3TXH9?6A9O_K}>|uw(f|3tXLIc?fnP{<0
z;dy!sR>7o$D;P*6l!a9BWFv{^fZ1TP5?{lo$SqTNbZ(PrOel&m#pD{}hh&U7&n~zz
zR?<%J8q^wzjiY9@Mlpu*4$M<l(x7v$Az@>U#KvI^s4WexH!RJ0Jdlh54MD<;L9lTc
z1Fl=3F=fsJI*=5i)k<0u$x{e64r7!+o`N^=V(+0f@iyLJVAy_#fq^+4G{_2R@Iae*
zXYMdCT!%?96(QuIO}saE7#P08<WZY=pdK`|%>`-Vfz&a|-eq9WxXZx6+zguG0<oZt
zG)F1WS{8T{4>b1$)eULlncih!V2r-Yz>o&l4PrrcJ4u0tHJ}<GO+2u5J$D%x=72PS
zyv77#5o+S?yUW0E4z2@a2v{3R6Axq#<MX==3~xaSK|X;jx8~}B?7ro`$G{+V57a(@
zo@WXUS?~Y?RAD<rq4PZkhG1lc;Jut6QOKF52z_X0;V=k-5(6Y<h#PT%&e8+5)ap7Q
zEj4>6y#Y#tPIC=X0i7C)+)@J#imt!MzyLX|7P+N%3M2{|>VS;9gR3VRwA4U{#0pBm
zjxQCrHU*tE3u%!#m>!l#w8BoxBelYc;2KIDMZgEbhCoh@g;c5_Um>-^wmn3uMnP#3
zy%o0pJ_Ezn`wR@ssi1lfwHiHrpMl{TOpd7lqySPeaxfdkAm;6%)hI|M<G=e13@i^A
z7?{ftsyUgB0uZX9)hI|2qs{{c1|zs?Nc{n=MjJuZsLulih9HnU*l`efXf+CobH<zp
z3=HKkdE^=pT8)AYnfQQ#VLD6^YBdTrWa9${hCMKOWJ93UDA-@u9xyOG1StafiwVR+
zRHMjCXdo>fu)UlQ85l$!LPHj!1>yr}H43&|?;!(&B}fs%T!<oQH3~K<_#p#B97qu;
z7?4eZR-<5(DjqU0G=mhOn*^;!LD9!J_aOtrVwfUGf&nE8aD@gsRf<6nWEOZF30`2H
zevDRNK6=Q&@B(DWYS4TcN`d+JAp--)BL)U$kQCE4ggmsslzqg&paGLdEigfYl+Y3k
zQecAAG5S4XV2A{1I1bwJ4q`!zJVz<eC?dST1T8Lr>V_1UX^$8f7<(QuFieN*2C<;J
zouojc$xscD0uyZA-bV}!XF(dk?gz056`1cIF);jx>i`+T1k#35V1fh~B_1;{$USCY
zU<UaFS`I=BOq<6H4DOGi1tzF-3kg0@h(HxW3(S(o3=A#E3c&>?NEEsq0qks$KFH>G
zNZdd*Z+y(aa1cW?NEEsU0-+fcIFN2T$TbXtpfeEQrR}RHkW#j7F@$!9(mS9u=*)m1
z9njeX$fYf4(o6OU0|Vqt1mx1z0wf9=iiXU;(yFut9YrA60o&^?Zfy!W(EwK3{?<a2
zwv5_HrR@W_hEhiv@aX{|1q|Ro0p}TzuaHVxmFGyMEhrk$OIz8e3=GOo85o$`LB%6#
zX>0kEfx!hP$219~0AAYeL6o1+(iWtWG3O}*LlH>J41{V<W}^)V)zH!wq=<3WQwD|w
zaMh4v23p!K29>tEo-!~T0Lg<L2a$)CwxBp?y!DiU;VDcWxuArWwqQg4KV@KGeFpO(
z#1Lqw1#F1?GX@4Nm^`u}(9#y{FPCQw4E`WRAb&A|ScuXVdBGT@v<2H+{)~a438V$&
zc!(B=<<Qa=Z26pL3=GRbiV)^P6hTW{ut^7>F)*9~DMB|1TH1n5diIQg;Uh>9x=GN|
z78HGq+|L;p1fMf7FoP69N?TB(0H++#)*uE!kXfju?X(wYrES1-28J+@AwHl5VvrmS
zZJuU7XJ9CUNil^Z<e{Z)_j3k@X)t-z(iSvr1TFp`r7cJu<DTaX497tll0h4AKrCo^
z=_r+_$H)LLZ9!A3P~DKy_6lfw^{?j)46H907?{DjK`f|lC#fosZpe@&q_hQFr~QI~
z!5X9i<TWM`i%@AB`+|WX7p?<j2v{3RX$vxkvF!x|Lk~zH$Sshf474DCK@hax30{<e
z4x|G$98<SIiZV4QJsnDe_6G%VgZ3dI7iFMH>K89SC%uD09JwfCe#yW9o`(YyG#lar
zZ95VShHbYIw>AasUV;^6i}esi*-Aa6qHHx>L#gBMEuh*aq<{e&DBuJM@)cwT37jAy
zVPs{<a}%b`%19VAP6-*+x0(SS`3DL7c?s=$gSu<rg)fk)Es0~yU^SpI2fbHNH7H$i
zri1p33}6DPV;4jRs27@vp##*j2fGwhLx6Qby7=IzL2^$IOed&+37M7x&!EBF11e7T
z!PKDSM<)MRMg}keU7ZNi0&4Gptww1qF)hwzWB?Nk3_g&>%z~gvDIds~iVqWbK-`A|
zObLSe#89>mBO7Q0)CV&4CkX1FK4D~G&CDxd5CqjNJ{;hH69k0=l<gzH0@lI-rUXHw
z20knhHfSKi2eMjI5ELJv5ov}fke5X`j><DIfce+u85kHvIGhw17{Ja+P+(vX;W(`T
zayi5@(8V`COadTV1h>2fi9^_+>-$7Fo+vOdY+>YAWMEhio?lb2;C}y_fnfuqf|W!j
zXoZuH0(d|j>P~QCw7ww@^7K=%1_>Jm?>7t#6TuuC@HH1G92S@iNEHV%M}XlOBL~<(
zTM_V?_LCSn>_C?pGcYWB!@$tS$YLkR-2H}uAspm(J0W3E96;E@LLe28y>xc`?4YoP
zazt1&-Y_t*FnEFzEeLyooXX4qjT%9a5ZF#TQRb*O&_Q#1Hqk?G7#IZ4!2}#wC11aR
z&S>0lG~@tX$Oqoq<Y<g!nWGseDD6Ua@j04<IRX%67GRD9gkuTjC_p$?V2%caV-4mQ
zKsYvFjs=8c3+6aLI1XTr2ZZAY<^(`EPGC+1gySN%T8NP$0m5+;*(k)wkOAR%fL&bx
z;dp{MB@m7mx5W<zh6)JBSBUX7149FZ<Hs-knt`DS!tod0F2u;t4B-Uw9~WX|=zwq{
zd0l=mFie1OqQx%>F*3}6aAG9y3NbP)fN)~L&RGHB#BqWW!v+W^p6l;x28JCFP6F6%
z2Oyjzug5}+3`Zc77EbKoC=uZR%@&DpfXV<tP@$s@N*vC1jEsJ77#Nm;mO_J514Q^L
z6F*3JFGv_fFo<y6f5X54k^ICY_~ab}0|+yL36Mr6s4`Hlfhc<nF@x<r0|OIC6rutm
z_mhbSq)7=R2PUAp*T05YVhd5>0#X5zgtUwxx?Lc0iEufP5k-(9)472OTrh!*Z$eW5
z(R~f#u9+}NhOOW%=zIqv4pHRE$OsDE6Cg#P&|(7dm_S?x5e`sthbYrv<OfN70Vx9q
z1)5rjDiubsZ@E7(Fff4#1`&>1@X!o|7-0^Q1RDWnflP&22Qm|4&=ZIgBSC7>gY*?d
zt^g(njVwP%SWN;6gN+B9j2vL?hydFRQU#J@0ue<}BN&;%iQzm*5|k>CBQgwP{0ER6
zIGR8jnLu0y5e`ncC+9<yiGO5Z0P6;u4^am3Su#X{El2^XGm%xThNy}IsRCOBCcw5q
zjERFNsDdj%l3Naun}$tJ7ZM4eQVCpPLlP`Bx<N%Bc*4#CoMjThssAp>7_du0ZeV~&
zWr5@Q2S^Ge3ic&bsu?UL{E2}9ED9!|QsH0&^*~bS2JQwYFHevZ!a#^u9ht#$`5-y4
zHh9D`fy5X@ID|ekFg#~0$z`x`VFz=-rGpD6xTt^>`z~By4huwv8_a<e%Pu@%4i7|z
z7tDc_(Jp*ojtE2sQi(tcY!?Brj0{9Z5X^y;-Yz0Mpt>7Udb^17gOaoXgJ9_=251=E
z1A9jIGc<UhqN(7J@db&3y$B8ikUydFx!^#}1<8Y@zyy+f3|N0JNFGf;Bn-nL(Y_g^
z037#V7RUft-UFEkiQD~P7hVA=1qnhT5MoRvBR{D9@c}LeVljwtfb4{*sAJ><wMvA(
zK>f!ARsk{iCfJciASsXru)z>{h~71f;C4?iNCDVpkY42Ca3iA>sID%-q5xt;JJ{({
zK=KG1K)!@#a2G~KP;t2$qyUt`p~6g%V(Sb@7;G_^K+?y?2zL5gkOHg*b3+vHePv*P
z)D-9@@Iw^n!xgLmEjvK6!W)ul-9ZXKnqj4U3!>0UM#zC%zRnB5=?|p32_^;3&ya??
z^L+63ZIF8xf}}wVWa*=D-3LI@AY;H$0@ZyOuKPYn8mt?n1}eQ8uKOQI8YF{k_)55L
z*>A8g0eKm!`vP3I4M-ZS8$>{*&%t#^gQU^z{t4Gz50VCH1ltX+yP!sVhZ_M}2?mK2
zkOLrUAPKI4Q3N!523jEo_BnE5+{q{gS`-3WG=`8vPK*Z_<wagIFff9aXn|dTNUf3_
z@01xBBsqR7gPPh95+Y)y3K9pch?3;^bO9s_At54~m%y@MHJ?>MvJmnaSj0#j+8A|J
z6$LfCz>QQ_HSu4sVB+dhpbiB@Ttf!bQiHHHML?-uu=_hqp_Uk^r3{hOkpvZ35Vo!~
zD1SlNCPLA0^`^q<aJHFnF`R8KQV(Za2qVn56qy4Tw-R0fXIqPGfwMh?5cYZ^**gQt
zJu{`@YTP6c?s1buxWP>dVXvDs!Y+3Sgqz(Z5$<%CLb%Oc8sQ!fZHWUgw|VGD-hi`p
zB|pH~dXgMJpke4?D0v1hZY1>t&Ni0%1818^iNMuciNPby!$uhHFArNJwjC1NT>>7l
z9!TNi;e`k*4{s!PIFjBdB=J;H1-Kj1#B_dulGr8<5V>Cil*Aw;MC6|)NPM0ah+M4&
zl7)~EkyqLb3@^Y<ND+=)9gwW09!MpKbOwt^f=LmMay^i2H<%Rq#lY~AQG^4u089|H
z;7pPOwAM}pObUXQiAi#R8Xl717P|-sXfctX%`cF_0s0^k)KmtKNhEk0bIknB0IASD
zA-yRm2hy8@ROp^|;4TlO4)=5cb0F2Wrz@BPsi{5Pz#K?T?dcBYK>Asp9$*fnpXKQZ
z=0N&co?c)Mq@U&K4R$xApXKQT<^+OECQm;wCkVm`0CR#NoFFhK1i}dcb3!4UXfP)X
z!ifQM!Xcb^FbC3w^GpPDA|W!#U``Z-lM3cULpV8LP7H*T3+BW^+7g~se4rM<mfs8v
z;NlE2PBIT1ub#DH2Y-X2F8CJ%gC|JY_1_E(;0`h)gD<F2=ry13_-_U%djYsr0uf&b
zuDc=ZWk_n)A*oppR#O2sM*>pkf+JSIJ4hhp4>V%ELzF>mNW^-Ff;k)vA{;t@pgGSw
zj2XlR>(uZr<G2IYSpjZ{L3LINfXX;XgU`DPECWd&-ZfwuNQ2LN3Rnh`SiEO3g9=bc
zgAd9P0|%k^Y>}ux3=9&Gr40t&t2s{o1r0!Oc&}qN{L8?wjgiB9Bdf$;m>)KYfGmf)
zWHXq<0vV<7UatkJHo&74-dor||6zcbvz@sTYR)d!1h_f7!CIl_>;ZFN=IlT+XD_?;
zUj_z-nT#(%#?52|ISK07{Zb&8Lj89D%z<PE?}OlAfMf>mLtu^y#IuKGL3%V8JVBng
z`4^r7z!ig!G`Mit&Zyzz0!}m%|DXdfKCUupe_(7kb%eM(xJ?Whanbk(HBKGUYxnVB
ze)^YzVLPLNj}O?mbhvT8(x9jXhm?<>8baJ(9#k_!j4Ov3rw=tQfZ609G@<w^@Pg_+
zc2Ih|r4JqcdI4j6gE3ePpi)9Gh60SC2V>a47+x?&1dNdeW0b%cO)$m;7-K$+u@1)A
z3uBytF>b>cuV9RyFb0Pq)P>?OhAE6u4r8>z7*k=4B{0Tj7~>F(aS_H~GJ={c2xBO~
z82T`V9gN`%W5mE1*)T>GjBysmxC3LnhB1D@7@WpXOC?|odl;h;#+U$O%!e`7!5DjC
zj59FCZ5V^c1ZuK0jG+Z%Si%?{Fh)3xkp^Rw!Wb<u#&sCu8I182#$Yjp+9eEQD8U$>
zFh)0wF$>0631jSlF^<C+*I<mNFou{J)CyG?!vw}~hB1O*j6@it0LG|?G5TPPhcLzm
z7~?;T!DkM&OBTk^fiZ$%jHxij5*TAMjByCYxCmoBfHB^~7z!3pEA(LuI~c<k#)yG2
zvSExW7^4%$m;qzFhB1D@7@U?+D<ohHbr{18#)yS6=EE54V2r&m#u*snHjMEK#`p<i
zXjwt+vV<`_V2p4WBMrtVg)v%SjL9&@A{gT<jKN|JHCY(OP=YZGVGIWtBOS(A31jSl
zF^<C+*I<mNFvb@cgV_dZmkEsF3}Xbr7>O`O0gO=(WAwoob771%FvfovgU=Rfg)EGr
z17ldj7+x?&A&jvZ#yA9HT!b+mz!>jgjDIi&uN~AbI~c<k#)yG2vSExW7^4%$m;qxf
zhcULn7@YP{lO<pbbr{18#&Cr(LST$)7-KJtaR$b?4P(55F@C}r91c*s#9<5%7$Y3U
zNP{s-VT=|SV=|1f2*%h5V;q1ngdL$)D8U$pFopw+;SXcP!5FPD#&H<q8jSH2#`pqb
zFgro55P~rjVT>RcBN4_ZfHCS}j6N7+E{w4T#@G#GoPsfAouPK=z!=srh8K(x31eiy
z82vEDMHu4&jPV}E_y=R~x<IXvfibjUj2IXr8^)-DF*;$488F6j7-JiZaTLb50%NGV
zLhUkxF<fDc5EvsF#wda@X2KY^VT@NW#!nc7!wqV(IE<kNW0=AiX)s19jL`yPOolNQ
z!5AB1i~}&nc^Km!jA7^wwbTK|@P{$tV2oTCqXx!U3}ZZnF}}bU%pOn!g<uRt7{dU@
zu!k`UV2pYgqYuWI3uCN-F?Pckr(lemFvbfQ!`c&SyBCZR31eiy809cV8;r3Q#&{27
z{DU!gy`Tolz!=&vh82wA31d{j7@aW23>afMjIj;II0|E2fiWJ#7@uGaS8u58AuvWV
zj8Oz*G{P7YV2tfB#!nc7!v|`PIE<kNW0=AiE-*$gjL`yPOolNQ!5AB1i~}&nc^Km!
zjPVx6_yc43`$C-&2V>;I7&S0PH;ge0#yALLF#AEZ3&9wQFopq)VGm>Y!5FbHMjwnZ
z7sglvW9)`8PQe&AVT>0r#&;Nl%^&KFNEjmn#wdp|+F*>SFvb!X<1~!H8vr#&2FB2a
zF|1$=PZ%Qt#z==TX22LLV2tfB#xWS<Dva?2#`p|lFa<(w7lbiVV2olIqY1{C2xBaO
zG1kKv*I*2ZAgF=rFoqe7;R<7fz!=FeMiGp$7{=HPV;qJtuD}>iVT>;@26HgfQXv>a
z5ymKiF`8kFNifDj7-IvBu^+~G24iT1KutD>G2CE`P#7Zx#wdm{nqZ90FvbxW;|h%N
z6vp@lW3Yxo?Gk}8lwk}b7^4-&m;z%ghA}q57zbgD3or&p7--DsWhiL0E;k-Tg4iM)
zAU3%7JuM!jpd2jqI|HNu#1`QIvB3&dGC>MhGeJ_FMIiR>*B~}XM1%t*BFO;~5#azW
zPyuV%1Xeb=2&7EB2BhUUSPMu*gaafZ$pI1(;Q*~;nZ(H9XANGbvX74uGM?gR!wDK5
zV3^NXl$y)nXA9=BK!y?g>{zGpF)~bI6!3Ef>-qxM<-!LVyM^g;1@kzdy4+Y#L3R0p
zb%8dSf`?T6{Di?{7ErtV!919*09FQmM#x#!eyYs;&isrFA{?Ilj0}^(vsH2Yj11t_
zabN;6W#tzDnJy{?$$<z45sqqpMuu06pw&MNexXc4pivKy|7O6Ifal2kB^g0ec<Vr-
zpvg(7d6|%zv7>0hd5nx8-`;@>gUtvKVFWGDU=u)g7<gg@LYVP0GBCUb@3!>|Waa~f
zxH3pB$T{FKN2sOcOyHqNE07$LTY{PSLBSmc5(e4M1R|hXrZa=b6N^A{AT3}Ep>m5L
z6UCE3a^NW=bOo~@nzvw4PzeeyKWk>*YamIG@4zNQ2(W+NfJdkNa+r8ufs}y!0$oty
zcN8*~2{Ge1BQLigBLfp?><lvE>Q@S$HB|$Nf}I3nF^F)0##h1N>9+wqFzSP%01{9T
z`7Pji&m1iB;E60hUWmt<VG5uDvJ?^^OF+UP%ODe3h)GAkc@TY|P1K0h08q{0%yOXQ
z3))!C1WLPL0xDO^$OsYwZMKFCA48mZ0z72~+IkHZWdivV*&AoUGiIPI+1TZ)!E?u;
zt=b5AXb{$cXX-MAV5b>^jD`%x3IuWqOca9V=|CRvY9&Yp59H+sE!u)+vp_y(koLFW
zXmr%(s|Urn2*)xZP;LXQ<pM7V1Fc&Ek9UI#l(|BT3{Yif5zHGxjF7R%&q9olv2kHY
z_74gX0y#twBn}=359;I-5C$0!S{()v=>m&D*xd+ruoO61dv?8JU~m&=WOxT1ZV#50
zvJ!@|<-lsddV}S`;@}h)^p%OXR+y2231k-}xPq>Nl}?6>f|E(mcSxbJ3QZWgM(H42
z7#y2Hx4>pxhl@hYcnV4D@6d#ALyYDUfx3eU#9|QP0EGoaqX{Il8-i4T6C)@GA-nk-
zI5>Pj^59$oA|UB4sEr9cv0ns|L(7{;p8f+iU=m0XNG~J}f#o4CSOan6W{?7qFt}WS
zq)&)~2M`74;R--31`&?`LX1#{Y-9rG)Hg5{P~m5gKw%bz`knzYof4uCF2EtN#LmpC
z43Y;q4H`?6z#(jjCOQQy8UhmqdxHUD#x^G2bdWg6^-v)LM&5du5I7G*on!)W(oz&T
zuxG(#8q|eBYr$a#iSXUv()a{O2PlG|2Gv6X<q1d_5oO?17^(}_0b%Qb*^(SZb)Xu#
z9!!Gf@+3JxM-oVK)LaE+sZa(620<w?Mh0i_L?1ZMS&KpQ5kG?n2WW|}AV@@nW4;Un
zgP@xjBZDM|3?s-;J!TLIs>UV3lFne&l2CGk49J3rdJyT|03zGjp)H<!V6JB)NYJkl
zw4SvZ%w}$eP8EcyfhRS<6CB|NQpdzVxpw+@=%Ssl`QRvd4m#urv}}ZF9q7DraG-^o
zgO`jki8C@Vfu(jKq)dcB90`yVBGSWV3xafm_SryURua5kQIg|OGstsCTcA!hZ3A)r
z+MwKNZ43<W857zW7&yT#3sB(&b}eHVc&V*mhBzYwC~z4V!(~du85tNMoCq+73Brj4
zb66mpC@_Zu!iffR1R$IkFh>Dmd=Gf3fZ%bs@x6+d5ytm{IZ)&K!5paZ6Tlp(@e{!u
zsPU7)9H{a0A;zmoz+AsT$w&h3`h{Q)6T~H_`C}zO(UL3yYZ>)OFfuTK%L6b0s&Sb>
zjT<JAabO9C58&cng7LOg>>&mQRw+h?k6;nVNzsh=IT*i6Ffyotf)heAg4s-9k{L|0
zfJs&`$p$9b!6XNm<OGvk41)6{7#T7m4uS4e*#Wi!WG17CBqM{oBqIZJtSKV{Q-&!c
z0|Sz*kt8F7EnGGaBn#f=!T1gw$&5jgj0{O|`BG5&16jlH32Xu5XYe|0MkWDfP)IN~
zNHQ|CfmD}(4B81%16c=CZ_3EP$Rxl5R<}ZukzpOWx?kXSDku*zG6}GP)m@NeWVi-b
z_Zec|KMs%!1em^nxnMtn75@Y&1bGs&+k`<7Bnob*&uj;!<gRzn^N|_Z7zNa%KoO}U
z#mKOW(N>C)feB<L6UcwiEme%-j8aMRj0|5H9SbrUpphlR$icW+iaN0c+Wi1JP>z8i
zfl-^0i?KqQkwG2o8y!Y2&{}#ZPnS_}i3|e+2SiSfQ3#aCG$1^E2u}yXGl1|6AUs2e
zDJBq}5rk(7;Tbc^gLYh6KzJq)eE|@jDWfnbCr5y<=U}veoct9j&Bzch&B(y)r@+X-
z0KbkU2POm!a)^I;80{Fj7*E6fV-GPO>K_LPj|F0zBZSAX034Z&E)eUEfXs~qS;YV`
z(txp%k&97B1{Oq3j1r*o0BU42#1N>FEhquj$_VaNX+SOLfLNd^!^prK54PYN#O7W`
zF;L)xf|~I=L})4_KS+o%LWYq6a%|c{h{RkZwWT0QP+T%VC6^#cPC}Pl!w6m!22#(s
z9wZ4)abPjV?TnBtcT|Rv;R48g*$SY-1$2N2M8Q6&f@d;}3?E?%AR!OlNyd1P5u6>t
zrgO_OG6>2tGBATof$ThHJPDBpB_Kv^Sw;p!H2G@~*R7CZWMK4`Wn>70$wRsl5KA5)
z8B!q2$WR7T1hwQ9lKcc&Muur{d5AAWm>}k?k!57K50hg8MK**0B|fly;7$8Xf$$O*
z6kSY`h~SWi8uV3`k>NMYAO?sf8c;bwIYtI?Ianw_<P4#5x^j#R#%OX@P&rRIMh1Vl
z9K^x45IIoRWXzOfWXK1}mx0m{MBV{OzEh5op&w1&jfo4CoIuqB<4QS3hV>wMaO^<b
z<pa^rcvOy&;Q~w!T$?~cHXNb=)E8xZCCA9{0j3Bl9}n3<1CCxUc}4~Sc~p-lLG&}K
z$ulw-!sM7h{(**C8bkq;yF4R95L^K$IYBPYU`%J?ny$gfz`(>H2r4v1I6y}s2!alH
zkmLZJZ6U$|vK)N5h6q?d5OhL=Bv@3019XpwB$yQ8038(|xIiA%vXburmCo^CG6zh8
zBqcdOrxQqWsNDxOnWl9zFbJLpE3fEcU~uNh=>lm22}^?6A{?C{C7<L$#d>KE1B2jS
zu<D~=)gU<$4p5OND53zeQ=k{5y&X(OO$QkWl9U815#a!d2-+%unuwLXAnQRnLJ(B+
ziEx05X%P-k;U>uex?)Cz0~8X1pm-GF096>f!DWO4Gvg^HsTu`FhDjQX3_qavLNLB%
z;$T{*fLeht>;dawWdXHq8Q(K;Fx^2@0j}Vg%0Q{d4^{OyCJrWUMO5>URBx?^mY)HP
z|CqR#)+xfu&;Lx|QW08yGBAUA(DIXk8N3k;TH!D<gR27pNO8@`EDOq?5)d8}vlwVA
zsRD$@4B=V)1bYYM*nUMuhFOY?49pcy%nXo%3SM<Ahlw*V`~qv3z{tqX%*AA`409s~
zGkC2K)Qz0X+@K~F)Ky%}0-!*Gx{8}w5EQ5)5O?q}iy!~ZzyNh4FEcl&D*>%A`Ix2K
zv>6$oRU|(%xS|CuYh_?y6kwJG$r(dT5o8tv@t_r^5Hq;ig;tot5S|T0r3i%Q0O5%;
zD}t6Txj=Yg%*r614}>QUkqd$FB$#EUX)`h;KzNdna4vxGq?i?#X)`iZKzP#3g6lOH
z89E?58D^n98jK7ZAUs)Sxoz5v3@`SA1CddVnFmzBbTC4yZxzU<MhRs`203L$2Iga+
zt3%;&pbZm(#0|qfuo<A3WAsvHWC#UGgYr9*Ca5|08!T%LVnXT(CJjcg5M#MABSS4r
zG4woPCKIS6C=W2sRAyvY0#gC8Ee&kX1ttj)4Ju<8nFN@?ijOHXGMs@aW`L->2vG+r
zUO=r)u)253j0|7U)Lmi%4?lu3EU2{!Rwt&y$e^gg$iNKt3&;qFp-j^l`9PL~L_keW
zuwrKwMg~uqVyL<~DC*e2>atZB84BU*z$G}7C1h_UW4j6?!!DQ{q*ephZ=kG0plZtm
zIf!Wy)F37ScCckPR2UiV!3<;ot6{tYDeW1V1USHI{-`iAFsVX)2~~3!u7(q=MnRR4
zK@CmKJ-8Y!uo@RtMg}jq8gSLdv=8DQaLtpV%E*v~CjS;GfLc@;8M@%|;Mik24cV0n
zN|}sI0^DGG)~GTvY=Wx;`-$lh#2!W_0UofL3#yC^w_$3KtHQ^SnhI2RF@9BLWcUqI
z<O52YU<WfkL6R3$V`Pw4V`N|k%Y$Qz@hL=}(NK+%!3HD;P8uNN82*6MG?S?asJdd}
z`wQWki5%2rWMHybz|X+YA<DquAkV<ipvu4?sLjC8V8_6q6vn{7P|LvJvW9`7VK)Oq
zM+74SLpdXZz(ytphIdTR`csct40Kru2h&ursf_x}{GbMB10zhpfSCj2hy`!~LuP(Z
zsl5U&U<6TN!OR2++7*x>1L<O965s^|8xy-aBZH|rG$}w59H_K}ut2FD!U88p(5_-8
zP}2(124LC<F^|bxosl6BW(HL5ml}BQFjKlZBSS8l+$X49vpOR~Cz{+9sN8&YMut@|
zIdG2)YH*V}#NY$!j0{)d3P9yHctD9M92B$Qm}4^6geZNj&d9)^0rMkRDcENqPeIy4
zO!DgR?9C*l!N{NrR}NMLG0zBUwY3H#gEw3OJh&idKQL-A^XF(XGBAM;#bDHAmH@5N
zh4QqR#XvPTl&8%s2-<!G<>@dBff79vgCHnkM8G*!5R}%y*K{&gGl_y0w?a5IOwypG
zso)!NEEqePI1)8sRbdwscsDAvD(q$wSfs%S>k;-q<e*hyFN6oJ{Q4j~Xa(I5;X$jy
z2~6Om2CWJwLU@LdN@Wrgculg&0!T8Q$^`D2L}@ZIFoPTgY7&8}AVCo4A7ikQ2?I0Z
z3MTekEk=g_jLF6fjH{VMK^z9AQjjF$I*0*`3p5!SmVr#E1)a_V$*LP5S+PTlk%94m
zCL_aXm^>3`go*)Tz;>ts4>cJX-oO>~flPrY*a20*q{Ya<tHsE`46=b~3PQn7r~+jz
zMg~2&f>{U!yPyhOv=|xu;R-;<*D^Ffjttua*;EgTY{oR03I+yG&@Ks(b>LBZCI%4>
zP*M>DiAaK(k{mJMdBF@Y2|6-PgkvjcWO0EOsI>|@;6@O1{*5FD=(r;h4v+<cpu+(~
zzygAxLwh8_q9PoiLtg}MXo1?W>We{b*mN*i0wzI{k{qCOW+XYLJORbh^(71pg6!HL
z<vW*xnz?J2f;54IB{@KB5sp(JC0g1bmuy?kz#wP}R?W5yq#7hA!U1aI34*R`mgERr
z0n&Z~Ofqi<DFI1Jf|ZDHfJ6jKwL$IXT`L$EJVAvLsEGp(7)Az9(AFMMvj)ZoWkXQo
z1;z)pWI-(yC|`sFRP+ggM8LbvB7(um5p+;6==NgpWF*pfGDHpNx+?|-P*V|fvoUxG
z4oMAo#5AHGJeUf)@fbV+3ML?9%@I9};6Y^2Ey!SPP+@<FaJmj71EfT10o`Q<F>Mlf
zW&m_gGC~S6!VPiJEwHOW8bEg_gDry?4UxVAmIf7IpsST3Mu1WPWRG=(I;0r|(hj<E
z8KND;gUTyH<U#sDS208MgXJN{e+3&45&+%M4ABlY9wPl7EDh2Py0{sl8!QcOMnyP5
zOb2NPUFZza4&p&=w}Hrm^n<Q<hUf>&gGWpwr}BdeLkN4C0H`Pg@4bj*g-rW_N9REG
zujkiS3=E(e7991w41ybV86k&7c&jloc!ErPstX;X=LD-^WLN}tI#VX^d0j@NF=_A!
zGE*tI`sVTkjn+x(L3J`R2y*JdHCD-kBoKqyQ1fQUgWQ4;7U2LL+ad@$CPtD2bV7~@
z2dK3w0%i+>j(CxT3V`k60Ffdbpc735L3db7a)7S7mgE3k*(}KsyakkhK$4OiphHw7
zIpSY}@+s)jTtU!1%90$6+d$b0bbqlV2S`|w1H=~L09|S;2)a^OgadSkvmof2Vo44^
zuxgN;2)H{c_(czt*;!_Q?5PHmTNi;0g!ENGY(a5-P!7$V0kRl$WvmDX=#E@)Bt<Do
z&VcRJin5pX(T7eyLL^;fV_^b?pmr)`R5U7xZN5IXE-1Jo3K_eGj8qGNMHC=&l~Em1
zN&1Wo$OiSYi5Wl*LLLOiVg%SA2Qb;t08R%Cj8K{hO0z&|4k#@Ewf3ImYBXyfvpK@7
zg^s{OmHtpuGGK&UcgGRM$;eS<z{s$lF*h@hA&QSt!~}G8?|#PI#0rKeAqbZRvW6l`
zlu^ak0J@+e>NF!b6EuP=5onNIW@I}KvlFLR8Fn#VHh@kyGl26=bU!Qq0|QV|4blw}
zS_BaSb7JI~_(Aj15RM{*1D+g<RRNc45VjGx{DZK~k=WK?Hn;&YgXtVQ$3sJC1BB^3
zyAX&2X@D?YV3&Aq2y1{aU1XPLHe!VKx0x=n^MU%!5#WXd(`9xc(Eb=mAD8J0JGfaf
z0U~#m9ozt!0`93YU1tZkF%B6rGMq4EWMCEsohk<Jsa}N%LHdpiA{>GGj0~RN4H+3g
z7+NBTaQrm{1&#wq4%Dy)83LEHHDqKE1c^v;?EMIx)C$=N$^@W8c?CfS4vTPrj(!#d
z9R@7P0TLDA0G$ji2s(jUgadS{xFF~VX-TlC2nXoALP5~Eh>{$2;DIO5iI;+)GY}=g
zav~g{GqwalXL(6-90FJNpi|leK}T{)g5@MRKzH^^a)55Rb%qX;fi67~1YLb9!U4Ln
zRuFV8sU!zT)EU|c0A0i+2)a^IgadS`s37R#NJ$Qms0at>N=8A@or~~ssD;enPNc9Y
zBSQwL70SSf)Xz6EW@NB6W@KQN0L>05Bih;b*}>V0G1!=qArhtl*0+BFm1HqyWMC{c
zW@Ko9ser@}xNE|=oEb43%_P7CR=miVkzoZ)F#}i~(_40UI~~-w2dg_}%*b#7O&uQx
zxEO-<?ZN6k88b5cg{cE~Yam@;ra7G8egY$t06SQrv<V}Fq6yTaP&G&4YB<1Z>`fRM
zT+!4BbHU8v1gl9lVPwceQ=<u2!v$8;Zo<gW3s(bf<}$fK)PR~qjLS_J88*S>nLw=~
zh9+?7z%-WwY#Ue=lK?Nsv@0fz3{0j_hl70x9v_6Tz+E0N0cuM@M$EyTIp}cE9!PJ|
zl9@peWR?inpMs#cmgE2>2uTjm@FZlF7ieUsh(UzI(Ug&)8PX`%Hw9%UkP<;q=UI{i
z)It;C08Ok3f@a#B!AwaG(5$8im=pxf{7G_vrZii?UIMkm7K4+L+7$+dhK7cQidL|M
z(G>=U|NsBj9{@{&PBZ%t1>i%Y&fj8SPy=0+#K0hSn}NZE5yFnW&A{Ly3^B0bHpD=X
zp$$-TdTxVF1(^g|0KmZT`ZfcD1K32VI}8l<5S^iSKsxInMkd~2VEA8u5bO+4tp>v2
zK`GEg>YOYyMh5UoHjprg!@?NKXvo4C!p!ymKLZ1*Ht-SAU~R9>7#U1JT9}$N!Amee
zY!JpOm<W;q;nQY}3@nVHh}H+fZZ{uh1{TH;gj5?7V;}=V@l#1g2FBY`f6N#enE1^Z
z8F)eFB%4ARpp%Fg(m}2P2^*Osd<m{R!ET*v&d9(B(hpJs!hA6GAPxe9@0bATxGmL;
zt|b7bjD<0jshEKQ;ckDhyFr31j3JC33<%d8KynTEd_IubbME6an)x$mRe|&;(8aRq
z7L1U?^+4@aaD?%tGKzr?V})_FkU8d{9+e-+nS6PSB9}ltd1=rkvCR1}b3pkBrd14d
z3O0<Rh0HMrjhLXBvjgOw?J#pd%|n=0G0<^^Fpd^7#~gGFBAPi#hZq=`g)ABI-Xse#
zt(;LD<RKVG1({<2;y{e9VH5&gW5OT}x}TQW*b;hYJxBpWt0<!kh{GTax__2A1Ve$$
zVweKZ<+IG|F&zgA5AemEAO^(Haz=4vjtVlz0K`Fa9O%wk<_j>pK?)$|h%(B6I1JLD
zJ879eVkiJP4x#{bAuY3y6;jAyxgHf_XgQ-eA|A>aRggIbh)98l9Oxcf=3Fai$bl3<
z%n@aj0dW|lLHE=$_rVk(j1y&)0dW|lL6_7r-$8a9BltR8P{4yj4#a>Mx`a^znWKu#
zF$8fK4l#o6vjwGN5C$K^2hKN6)=(FMRDnh#86>W;XoDIBjG<g0Nsw~vSmFkY6k~uj
zqHJJb5cs^0fdM4M9AynHO5TB5WYVC!aG6(FBLy_XFQ8}u`vt^+`vsY!ip((taTpFU
zg09VlISSzyJ{zcCK&s$=0X2abL%BebFfEug*e^0RD1Is4!@vL%Vpg+(`sEDRFQ6-T
znM-Vt{DL#lEMb%Y#U;#Rs>mEeNHPFj&dWR%=5n|KP#Ohs7^Fd$?=s)C0hL<lx9dX8
z-N(oWiZ2*P8kwUGidF_`(B-_$vbIn&Kp}z_==&J?K%#InkU8q0;AD^n-PFsR2r~oZ
zHn15WU%<5Sfka^(X=IK%NEw3w=pfX5TSf-vN?T}<W`e44>A8&z49vT1q0tBO0QiVF
zkmEH$k;R*=1`>p_?GWq~DUccl0nmBYCqM>Yf*E`kG)5-?x~1a*Nc<H{+zuRvmq8Y4
z+d(Y^`4(&;$fr<C)IfqzwjF|<A_Y>zAON~?z|xM9f!Wy(>XS~;T?^8jO$-doEii*Y
zK>#)w<b9}NY9K)<+YZ4_kpih<5D<F7z%U79@NSsFL3)e~I`Q#&3|z@lpp#<3BUsT%
zpm5>J7Ow$SNet4U3z3;Q?4ce41rXR?Q0PGHDpm&xLfQ5Rc8N4d4cIi^21uzdu;dW~
zgP1)d1GBw7)N>oP5N<g8hyk*$AI%K{ca}0R_=2>B!?an0CJv=R$7?g^+cPpK#m6Ty
z@VsYKdk=~n>6a`F49p85;sp$XwT!Z$5g~B;5v*m@LgrY2I1JLDlU<oXN3eoD2ReNP
z>>;Zea$tE$a7RoUbi6Aw=q?qoD$pnpm;qX$2{v5f7_&Xd5D4cuvjvF5APMfNNrTRP
zWp;6Z1|(cF$b2+Yb}>7EG(t?-&1?y>kwE}-tx%8yBLj1c12pWSKq*cDbZ=Ca10w@d
zBTU@i2pl4r3=;gzTA&+;7*s)eK=C@sfstXZ10w?~NC#`N10w^2H0bhb=2tL>fl?&c
zJ)q<W4g}s}b&w#GZI57=NQ2a%#&Gdn28JIXS1LL}U70J7h+)um8Q4;p!0avt27O0H
z24+i`HfGRD7HQCR70iK-VE;g3csnRJ2oxP;V2B5)Z-%M=5Ak#bgV<_DaZu<g#m85I
zIEo++gEZ)}ZRQJ((BKDU53nymc?0S*b&w#GZI57=NQ2a%_);2lI5P8BxU)7hDooS^
zyD^V}XEURI1n8J#0T0lb%TA08%yLf9pnzt$0tT)UDa3)z0-z(Ub(|O(n5>Z%LJqN3
z1!)GwoR1SDL%0(o11m@+tEm$s1B1Y=M+^+9AR8KB8ll+<Yy;u|eu1+O85sINHq1a)
z$e;?+2Qqx66C=ZVkl`Rj3<4|fGBE4~nR^4K92$vWa}hV82+X;|!0-%Y?gwOr45}b~
zAafa=85!7}85vkXiWsCp*TgZ)JA*?C5}Qn*#lg~CtPBjyfe`Tm2Ej(;{MyK90E$3x
zW)N&-bOCV~q(Mg_GZ#8TV-s|;DLCS+X2^l%1wgk8bT~6IFwb)a)lH$0gX+P35kwI6
z@PkSy27x2{7#P+#Gcqt8c7{gOV@P7kWRT!wQGU9Qfq_94WDv+pSDYCc?t{Dp(!sjb
z8I*%SSF$r3x<Fk6Dgwc23uHR@!asPAfLERo+ynyqhF6}^8Kf4%QGm3xAP4_TgDw(a
z4s(Hp)MiG7ms(&BB!N|et`rd9U&FwV;=;(loaX{{cQvS36wqJ8z)%AcZ$lLiddk2s
z1tdNXCO!{bf`CqVUjq_9j4ZAMsu?7Fm=!^XL^BA0E@gNLQpDwo6r$iu7eK<0OBc`r
zxE(xgw3LynT^4c)1A`TZGy{W?E223x2^6N_1|y#*H2gp%q9sV!5tKMU3<d^<JP<8%
zUI8QtVuCPK%otfLSyz#PfoUScVXze<*Lgq-<(Vc%@PUj6X+p)|;SB}`29fKQY;KGU
zjJlp+ePBh5ibx!8D<lp=4NSjiuPke-CnE!6B(gGJBn|@upT`!2Mz9TF0@lnFdB|o3
zazYrgsu)o1237_NBQQhcAzP9=BLm}P(4Agj5e5dvHe^mE631M08NyQVKnH_h9isrF
zC6X|s4l+j`iNp5C6FdwGwFXAP1|S4O7)6ypZc*?;C}R{x=CC1gVA>d>!F})$rWyto
z#z1iQoJ-mV$pn}^kSQ0?28kd>aYiF#C8|gq1_lPcQY2TywKKrO_BPvMkUM*jR53Oq
zaTxf{E=7bB!T?zOiris)0y5wUk}AgANE`+}i%r-J;D(wd@`CBS2O|TcKawg&HzW?<
zM<mk_Cc%6lc$O&@q@M%H(Tx9*w4f$0gaJ_d83fPC&jcBOlDxQ)gB_-lfdLj3g6Bk8
zL7~ow8rpI&m7rUV-+AC1BHHK;mSQRc4HPj=j9_651YMgTz2g`I12ZT;flEnH?gba#
zqFvx-8kB7c5@(Qp08*QcTr@!Blhi=+P_`?G4Y{peAXAiqq0*C)fw|ceS}1~x5dm*u
z28M|s@$<;y;IdcHi9_M30O&9?P*QW^Fh_8lIRrpvLzFplKw5(WF}D~Po_R7dF#Sb#
z7`X5=hSwb8%<|xdn<~gcP>6|pF)}E5Ar*40ATwCsg9-_OKO77U240K|%vN3~&fdep
zz~BKA4?-0O-8YsA60i4y7RR9BBCrz>b#)IvsDZ{H;IfB-q1TI%foTcMkb`h%a<V9=
z?g3SBAcH{8-0H>1aKMX^ffb~Kb($Bbg5y078VK@+x*gO41V<gnbZ`X+vKt&mpb8Eo
z4dXZ?I0}psAoY-Y#H2y@k}-qsdxtdLH!~`1lt-%I3PCrNNpgU0+LI0fS)S<)@@7Z@
z188_!2h`l>yDb9JuM;1i#K3o31;l0$I5&ZTq1>C1fw|Ee8jQ}McBH_&2@DMVAn}=~
z;-D*hmxIJXX%!rL+Mv5?k1&Epi$z*kuXrPJ5_p0NR1D8K<ip5-y@nFJE*OYjYYASL
z1yw?zumxehr;u@85E}`DZyo^EL^D;F`G5vMkyJ6hN8)hp&qKHg!Gh`M*}|y6_y}3a
zHDu0NB#sKq`V??s3NN13E-;{t`Z5R{yUf6F!H1E7`Lz!;V5NRBfO?PMCL!YfW9i$w
z85o$Ee8Fx0A_kLQ!}XvxhIADu5|w<RkqBzA>BPquG4OYZfS0sL&jralVan@^LFBzb
zUAhuqa1u#j5R70H2jxqp`1oQFM+?;I12<R%BN#2gp)J71!obkv%gDey(--PuA2G1@
zVg^AsMrg0#0La=izR-jXng|D{Tpn>Iow<693^0y0h{JRp)FXE0kUPl0ApHuY@e|Cw
zAZeZW_!0*GWC0MHL6QU1X^`eU!N9<5;0N_JNC=#C`M2?dw1Sf^|29bw8{EI(KgbPI
z!{E&E^8f>bv>`}$7)&=v70eD0n?XQj8v{d%AE^E32le4&@SsO}0|Ntdj~~=iAQPG3
z1cP)4$kcl<Sx`R*oR>i=z<C)yTnx&~AZc(QfEud^jsl|uNIm3g7lFp@3=D5T?qK$Z
zy5k0{H^i;VC<VG*oIx6Nj|{V^KR5;w8F<bzDnYwU1t5+-=-L)=1oE6^w1f1YPJkBl
z_%kvvMZ%12gA7<CGH|vkb%VUB3NjFsinII~8A|;b8Cab`gpWU{(CP*S!(@MGFn}84
zOmKoh8gxY$^HF5?KwH=l_keE1g1ZOO+y-6db{XWJXE67Gx)R_*13ayv3Nj7knD73K
z41YoH0I6mWIJby_fjfYafk`v~8a($vqZFzjB_QQ$0gMbf0gMc+AVmz)>p{-;3V=Er
zTx7xt25Hbej?6UyNWlm#HzCdjU7HAZHn<QK0A1SI1+soF%z97-f#htEX&`s33t(i}
z0&)jPHG{yhb_Rw+Abn?G`j&yZ-l`xaAmw)h7#SXel!Fv8G%{whGBAjkF|x7;A_^r=
zD3fu{^KdLhCV28ma2lgDILCqvWnh3zQwdH3@2-LhF));XGx{_}Cs0O*i9)nbXXHiJ
zt_+eDv0@b0gxU?_2ZIO^8%9BpO6G|>>J>nRkBBWJ|22>d6tfvZdJRx6jDj`6M64Kf
z?*uY3Fxn$46Z?+Th=XVWnL8_pk%5tQGr|pASCLz85QPk&YgZsl!N<(vjE|9&p!60X
z4R?r22q}13Dg$H%YIClw6k#FE*+_O=mSUWOq=JEgfem|~1l9l)abRRRk711%a-RZX
zAxPoQU`7VY`W3LoGN@ls1u~7Senlu#9k^cs+Mt4?Ujd#22Q~Hx^ea$&3JG`-Cq|~V
zA(Z+QHg^f~X&%Tl@_fo#$56(g1e*OVXJ7;MrD_=%7;yL*d_go3e#Vg`Aiif{5OHM`
zegtwcO3K3)P%ey2=R+wCD0obTFp5q9nMPSa1v1s3hY-wT&?Pv;gpdJJ7afxRL56^f
zR8R}fosr!=oRNXi4oMjwa`s1LXIMrPyu+3r#>jwD0&pYeO_)NY&e>%tMwB>U;GT(8
zet=vA!K@I9LGUgM;|3%ZjLVTY+#yH>1Hw;my^oX_E09%WBXi=AI9#B{G1Nu|ghycp
z@tkAiWPA!a*chye@g_0{)Wie}GcYi~o2Lcf<|zXM8*(Qf;YL`{h<GrvcY?wlcQ2m}
zdoLeWREl^qvY!T-fV-OyZzO{{43NbIpzJqsM?C|Bz%(ufhOgm_49x$-p*20I$;n`4
zCC$K~4%&eM^%`Q(i#Y~b&x7hU>|F|x^9mqIs8-lOm@%>#&OtAb@i2`D8a}9T-ST$?
zBLkyS3?eWY#gI7M`bZpv8km02pjT83BLkx!vN9(m4l#pX`jLzbs0ld+G(-$@F2q`q
zhiu_dj0}v<&JaFGmeCBEqlv`9Ht5w%%|S15kXy(qiRe4%H3Q^M+}VNfpw~^10l0Gm
z;X$t>(Uc8(MS=8FGU(L@G61EVq{5)r<7n{67Gm)eVto;;TtFZ6nhEN5f$|f$w*|_*
zkin}iStPb8h|M5<5TrH%xoCi>O;Q8NL)oq%He}H2D5K^Q28O;EP(L#iGSvYYR(ZxK
zh3M5hV+60tVUT_YGX4e3cu=1R>?Sw^v~L5_=`&;mFH?eWj2OW)x)6>rqbx{0gk!=e
z0lKu9LE88vXq+e(<PPZFz)ql?3Yz6mijU7^kT}Gm4bsLS0J<<%A(oMWSt}M=R6^z=
zESEDdSb)Sq_fLXrR0C~rXD5#V-j|f*04-aU23>B++!G5eKtaZWy#d+*0(KT?HWp+G
zgmawP0>ohuNL|IiFbibE5}3_F;8~O8jSLK%K;n;K;-J|SaA%4;gH5hx1p{cBxtM`F
zgH0b4^x!o^+_`K*T`L$E7z9998Gi)bnaL3c^-wQ-jE$dJ3v>xCgDS{qP=H9rF*2yc
zF*2}%bg=%4Wn^Fw09|J76$jcP9|sCQXgq=^SU|#%i>bjO0_t|^#K#vfa3N2yfVU?x
z2q>;&V5kHc(+qP5*n3vNn-~~2#vw}2CMc6}&ao^;2Cy|CX~;YdxF!PY1GyH~DU+PX
zs1&{mD#F0Pu#8c19;4}pI7WtPjMqV<JTNJ6A53x?qc}KdprR1L6^#7rHbO-h7#JXe
zE3pZ#!lr#SHkE5o1;s!Si?9O30=Xq2fsujn1SqIMBA{`+-N+nJ)I%j0>_80Nt4Pvp
zpt(4ZC<sGC4m9lm;xaHWaA&azevfBlU<6IaLB$vt#B7m94<Vx5xoq0HAcw>tNihZ>
zaTvIet%B$Rk+6m^cOIJnsx=G@Y@l2KQiL5#u3|Jk4YCxJ>|si{U}+H~fbbEB2g2OD
zne-XK2@}L)V1Oi51_riJq)>siycif@JvWe5tci>ataY)B42*?HY8k{pIUQ;k1H?kf
z)r|Z%6B!v89g!3=g0eqM9XKY;K~t+R5eUt#!KldS0l97iEW&7w#4!i0R{;xyq8ZEp
z4~uFeO^h+hBXdBDQo!mM7#QHw8=zs)6N%uGo~4+<NCnX%HM#&%EC$Lu5GDi6Pg@ve
zqLUaI7&)>bo&-rVe$7JSyg=fZgXUa8N<bLWT;{pW$im2sG)Kz#3CVAapxIWCVhCmf
zmHH4S%mpBx4v1i2V36F;$i|b#$iR3Dsa3{!7MXJZnX?&*!v?A%pynX8<Y6Mb=8Q~=
z$&3t)EJ%^Z1)C-ZsX`<V5D$bU4ztKIg6GUZJW#3v&7w0fpjZX#DnOMmFff3u>cMLj
ztVxQ{gUc!|(BwT#87xyVFu(!~WEG<}a(K%jaaaXi7#UbuTo@U+K&z-=#=yGPNX95K
zsxrQ}Lqt03V>?C$*6VhR44@l=!5U#!>i$Mj#|>J*29^f(Q(+8*^V;|s*V-Z(yU>=A
zfpw}aBLg>RsUJ)|EIT4OC{>#AG}1Ce)_pdN46GY%7#Y|=OGRNC5ws+f$#<NQ<5nso
z1LHX>gtd$ZkvUtCI9#A*$55@%90B6NO<TsO%lO>_$)s1voV!RIcsRlI>atiO^l^dK
zWrIuxVMx9Kv0!TXni%C6d5}zF{ExJ{oADD82h$!&Bz^GyUJZE8Iutr*4L$@DxvT&!
zr~Q-)E-RSokd~W+#6jIe(7+7Hfea`a7AyiLOu-}rgXA$rwtbmY$gqf@f|?A@MVCNj
z0nQAI2uGM6T)7A(!@|1HFinsQYnzU*Y{1OqxU53Su;3k<V0&NzMplMJ<a@X=L}XZ)
zTHF~HQ4qk?@)DO}xxjt`5pa#9W>^J~Zcv-#I3q_lC<RfJVd18ckzrwaiOH}qwd7=2
zm|k7H8MYog7!2NWgPviRWP&p+b2$SWq5}uZu`nGBTw<+=%!FWpo8q7<_9~+YqZP6e
zU1W|55(i$?!1Qu~rl+9shD5=VC$|BkFynU6WENDCaTPLWE)s_ev^Ef`3aQ+MnFJno
zs{$<=gsNf8L*{@M5ke&p0Rb9zLoT|c{gyB=F!N`l_f9~~8A!JQ(&@a#D1+#9-eOb(
z^~{zt^4wxHf-V9R$dP7XP|IdyVD`<1_TE5~x!^znE!F^ca0Oo=R(J@$ummY!>IF5;
zr2p43FfgZP!)9lHFgk-*5en>+VPGf*nL0Ha+5=mr#mE3QOz4zOZZiV|c#>7<EZ;rQ
z_8x&pd<+bWLF$jg)PpRCOeuG>%7FTK;NG8LH>);i-iSe9o-_l)J&+Ej9Bl3ecQgg}
zvC4xS3*(rBI1C~juUbG`JJ+-_FbHzwFfs^yZ((3i%wc3;*3N;tmM;g?4HR!>V6X&<
zJEMx5w=ysUg2bay#c#7RFl6R1GB7p3#G$@OWDs1-sN@b>&Y%j?1B%~?IgAW*au^v{
zK{{BAz!r9jGBB(H8N3B%0C>>yD5GL01H+>nXl#R4ctE1}8KV?p%JCT^cry)ybONa7
zZ<7lR7SMzxxHArCY-)$Dui-Uh1aDaahYzn2BX|ulgk#Jo3sMi^m@rE01<f}~F9n&L
zmJ4!6NC5-L9pEtq(83b<m;y)}gFy2`28NPcMh51(TxgKifO@3@Ke`zhdO+ffVd6hv
zYfX^G6hND0rT4vJU|@cL;SJDfY+z@B#uPxNKsd*lEkGOw0hN9RhIb$ve!y&y0xvsJ
zn#RDumdD7zY@P>o5okFII8}kh6s&u3jVXBcg2oiK-e+KN&0}O>ih*g*Mjlfr0QpW8
zWHcylbMqJ(D)JZ^SV1~i{XpwH1jOz!Fw6tl4_Y%K93Kh^KX7LsB<wy56vE(q2bvRx
zjVXXa6S8O%EYBb?;W7gQXyFL+H<&x1i$B0y2X<b@v26d!B?bnTd`1Q);e4p?LE4z)
z!ATNi6v){s`HT$u`Jh%ch~Uj<WMDYL=na}n{>K^w;(-(~Ffc5H(u{KyOL0ymPi7QM
zMp}LY?mdEs7(|#EMUW?iA%ZNZg2qrQAct%)Ffe>8WMqI$9dj@Wfr<d8i5?K0oQwh}
zGsnm?LNHSpAbTG{GeTU99Fc|iW`q#c3ary4c!#aB0N;!dqOk_oa#;#>AbrHo2yruV
z%m#%!?jdkOGeSI!9Ctw`;2r~q_YgoMzwJznAxslJz=tCeT28>sD5712cR2whRfw=K
zio66V#JQXRkrZG}as0~(U<n41QUxzdZ3kI_I#7<hoB+{ahucB)asrqR5dlUvxnlI`
z9+U}Zh?hYQgE<nUDHuZ&%7imS6G)+X2{k92e}JqdYnmqzoC0vn#KRh8f&^9{a3L=#
zhWHT_FyQhURH_IuvJknR7)t^<%d`~~R+LPwyaXA5nqtUWPt3p|eF;>_gQlRttp?C3
z`QREBv<{C$4A#;UXR-!yAnWj?4}+S4pcD#emYii&`XdUSDS)hma;*c`t$7Tf1!XOu
z#=HO*69WTi{R{KFQfPeyZs`czWoBSlQ_9G|d>2_9>;OSKMk!Fi595Fvg5Z&VK?g=&
z@K)wV###{u29c$Vtc+!dNSXx=a>hBDO*pHolN>T2!$FY>!jSb$CpmPH1tBY+PI5Sd
z+M^&<APiA?iUUiXwi<Qi6QsIYgDU6>GGj+QBZC5H7C~eKBM)+A2GOz!N8K0&(#ycW
z@UemsGI}p^l2H=5YGnhh;)E(fqQJ+vgHr7&M$Xsej0}uvkfX7{N*E)NIX*}nHa(;b
z1Yosb0(@8=XsJdlqv#rtX+cQJ7+sM$7Dya;Sq&Y{VVSt2o{fbugbC6~1P#*Q$g{8!
zHNj~7I}x~$*G7Sz3MOFVQX;1rIVoEs1<oKKpNBAtZmeKrU?i)23S|fRycWE62+XVj
zF#}m^7-|`0a4sQ&jlK{nxER<#D|NvhM<L)P*JehRy_Jj%jNM2v%?Mho3scSp+VcnF
zAaWH<M9_m#z7k|WsUt#?F$0Oi3fdjWz=doKOf!NO^kkG~Bwz%C7-o7FIl#!gy^7K_
z3_jo;6qB)xq7@+1$V<bB=nDZe!I2sW8id5P5)4+A6H3b{IT;bo;KB!#llL()Z>^>@
z6hK{iP>cx1GK!XgOd~H8&~h@yDldfd!G{2Wf}KE4M)5t!g%Aw){Sij?%{A2YeF@04
zLF0Su<rw&sK2Y2rV`Sf6OKDpRT&sejB7{-20%RI_Wf?5)IqDf|7?f%mWI!t+@uUEF
z5lW!_g(C$>K@tLk$Tmjiy>*nP0Pvj-pfHGK6s-f9MqUa4XMJ!XPVG_vM~w!)APSTc
zb}%wiR-=JW(E^14C>7L`U8BKL0kkg16aVlMfI$2+h&^sYlpBy(7g@>39?`(az$ns=
zkYZ#<=KMm^#P|`3!^V%a9vq<?);kh3XH>TV87+&X3^5#wWmgWiwdd;?#l#wkTYC<#
z&WT)m4(pK#UY2?SawlrjAJi0wgc0&YG~9DoI*Zu5H?WqL$Q4F*rY53Sk3rkp$V=+a
zGR**m1SMUZGav&{{fWJc1NSHPEtBwu=i>nIlmk;Scvhm8frT*$oM0os3zJ1S9=0$r
z2!gr{0^zL;3{Fjq3`{;v(B6tZXw8nQ35aB1V2EvEWJqpeWMBm;Vi1Vj%D_+vQeF*H
zz7@Pf2BZWOEj>+)43j|0L5dh8Iau02<Ix~ea7Gg&gY+Lz5A1LgbO3i_D|mBP8UvfY
zB1oD+S{t-S|63EZFDBT=2=2OoOK`z9$YzZu#`yRY2Eh(S31(>q1_o*QQw$8uD$P(M
z5u2;znKVJ0q`-Q4<e4l$90q}nTNxOPni(0GJ({8Z1$jUxKE8s1J5T8t$TI?0r!z2w
zH8V0W<-*kbg6uR(WZ<5}sPZ4ANEM_X<m0+#MuyI2Mg~@p4%YZ)(CB*bHU@_2AWIg)
z41jEzasfH@EX=8(y-nbG1A%&ZB(^1p%^<+Gh=Jh=$PDQgsMkOnqrh!jkZZu+;@-vz
zK28G0aRe!00_{x)1yUXZ_fA$3+Zmuh$^hByj%*UxX3;KLkQON06vSqbo&Zu?fvGkL
zarBF5k}F6pWL==Z((MckZ7qxp%&S_UVR{1+UIh%?I*hU}w?g~K+&YY!;B8t0#akH|
zcC;`uFr9<x*b3Wp#ht9W3mm{8!$1LizlD+ERSP2nD@X(D!4}Y_tGys6f+ozsl`LrL
z2kZrbdU+(aC5X)+5WAd#0W>|v?9mE!9dxZ9#B~doVz`cTF#|(bD<cC_CQJutD-}5C
zAzQFOCV`w*)yl}w&<cus(Da*t;8F&LK9If{FnzqBHGirgB_QQ1TNxSFgOr05F-SiI
zdE#~}G<HG5;V@4iu`NMt1_7BK28Nfdj10`YZBS1@Cl?@|Na(`w1Y-vSgLE6{^mdpI
z(8ekxPk>AUxyrtck-@c%k%1MYnnB<~Cj&z;NM9^W-&N4?y(&lvNO@ixBSQ&DIY<$M
z2*=yg3=D!G0Rg_#3=F+(pu_25I;%j{lE6Db28N{|aZo)6b^vJZ2%KgG+u0>S!w@iz
z7Kj6x8*68`1C2#MWIEWv1LF(=o0%CHK$RV{QadypK!Ym~MW&33Anh=YA&3Jp%ajo^
zt|4$ynt{Qxosoe#p&c6RAUoi00*Alg3pJ1+lx+!OL#G7UL7Ps?+Yy^iSAwQSq(7Zz
zU|^o!4xKszo$3SIbZP*agOC<I!@$729aCOk3@mTev5A4<DN@xAEqNIj=lq%sT{8)i
zhAhn_WzD2Y2WZVCWW^>Z>fkFO2icm*DV?-kGpP+SpO`h1i6DjaUNiY0WGQ{tOj>r4
zvSyOEdr+^L{L=+)<KS8|DFnGg51j5HtzgM5j57ToKZPJmIU;jRkT~X`rPE;T44}Ke
zKrHZ@$rPmJ&5Xgw9MA%4kTM8HS%L*|0Z0P29uKr;(xIOUORx}4QjqZ=3|g!d+JkRh
z6s(O6QVqel)<vN#!GaCxK(v5JkW~lpS~a?6l9p>G`9LX%q9s_cF=IY5mSDm360-yg
zrk0!~STMc#mtaB8`N6toQmr3cR)B^pg+R#`gkdYNK*RAMJ~3-1KTV=ShDDSGU~8c(
zkJ%>R%dnW4oTv;7>o3AAf~=V=#A_91CdXyf=$c7zxDs6C3|m16TI9SRl!7SAuyE7J
z$gnWI#AH~QT5>WhOfUWn3z-fBO`3wj5jI560Lqv*CV?~T=$c8Q)=Ua)Ud6z`F@=$V
z8Pw_lcW1!cs-)XNYbm3rfVw8gJH0^797uNpGOLYeEhVJ)Aj#3cn}I>v0@Raf1RDq1
zcqb0-36(JLds%?&V6fV|iGg7~QWFZc%9wG^qiN8d3`iQXj1!|L)4?Q}Bz<EFsLz73
z&npIb`wJ+gFfd4_%SBElZ}$tN^aZ!%h~53dmyOiQgE#<0!WLLa=JUl&V`N|i?S})2
zgD@MY>jq+gFvLm_3sxR;bFv722YUc1v{3d+AqsrBp0i8_*!D_s%|qHcg54^{tw>5(
zL5DD+*adPKDwgnNHUe)L1aBP#E%!$D52{)aPcoO~7$^upX%NH*VH7J6?gB}HFgFhG
z!0Ttw&O*?_VDK0w^Jm5o1_nuvEKo9x1|>s|>7Y~%N`|k&gNWc{2ufxQ0=*j<7{sPC
zGBDdthYk{easzl=fV+%M9<(zs8ahB$!6pFOa>>9Tz%0YS5CYOvHXS-N09sND&P$--
z3dnH4A0?0=lnp&Q?)4Q02Ik)B;JlE?ARcE7UJNVAAt}qiAn;m-fng!Y)a@{*fL06Z
zfX<l_+OGi8#UR45QkH>15TrmrPL_e;0!aBYnDV{T8KDb`R|@ce?uxe(n$Ex=G6NBy
zh~WawCD2R;l7_6h1ZOhvDp63FBX6-3>xYWKw^#<x0A)SMVoa!<GKdCkYXq+p1##eG
z2rC%*bEiQ?;DRf$39e!k$JD+Wo60q)f?}X`t_UkYERb6c&tzm^lmV?g1&M(6-ti-I
zKr3OP63{J{nn==Ypd;R3(uhC=-^BvmVi^T8A9TDMOc|~%mJ>h<@eCIrTLm`@a!n)1
zD$o{76l)k5*g%Vd5lYcnpnZ>evltl|L92jal3cK*xgY_Ak3c*S25+$huhRwbK%3z}
zD|Z<f*jDBu6eIeBuz3-XRT;Aw8CWmnGBPk8MN-Qk23q(GH4M550JO!@W;P=O<5VPt
zjG)!fFm>QXvgSg_TTsDL;4PM#NWzRVNF4K5ptGaF3SrYd;4PNCNNX?{8Id`lQ=y^i
zQMXuX&jz<Ba19qYBAtB)2^Y|C!9I|mnvtankU7an9COgBXqe5A(i>dK>_AF<jLVTZ
zptaF34GauyphfU7F2n^O9`bNO{(MFTMm^*ZRz&8AAamG}IBcL5^B}`O7~(V#3x+{`
z_?9`042%&-dbnT*HG)(jk_U(f!r(3e_|!%a50t7v=QuJjpjd_3lK@%u9<Nn6h6}J*
z#RWP(5^6g<Q!ya+Fq$(mG4dd#CC2}tLnfgbSU-Wzo_y-X$iM|Us2nQFfY@0D3wK`7
zj;)JGsgU(3=wS1m4%oI>-bGT!4LY(PW-emm72Mo5envT@9hs~`pq-m+c8m<%pvw|q
z8e!QH$zQ3`jQq%ZGnqhpGrxkiSb{FCfN4a~u+B56_hAc4L9>wVykP7_<}@I2xInj}
zz)V4;N4ROA-p3TAt&)uG$eb!94tzfnOt0=jBv~%djW#fQ5Q!6}7To&?LE0+G=#I>>
zLgHZBlZYe>Z&yGU<>A_53A*JYbUwJOKp8FoiG!LWh~Wa{3=8uB0|Tth3)*6-xR?qV
z77_L^OF+5EbOF8$iwH-U9-=ZVtf>jp1Q{+^fY&O_OpePclne`76@UmZkgrJ2u&_2b
zk}*VNSXdnC;>@s!f&iu#w8fH$42#I=aE+v9SXk#7lwsd3Vq{>XD8s@{BO}AY^b(U{
zVQR_AurR&4crz@H;Q~;`WM2%<u&BcYAPG>8g$*z;aDgUUVQCwYt-x)3*cQwGpqX5#
z8pcn^9MJSDR06TP9;TNIbd)Ac7D2<3CwPlxUI4;Q#zbUJ2oi^DJ@S@GxKS{Zz*{UY
zAuBnC%mLk}0Mi36@zA$e3KaD-Fqki4WMBrhdca-)cM+uBIvE(4yOw}DR>+&UK+POT
zcLF|KfY_UNi%|_UMZFxd^%By1kmPU$_0#G={j?2W<3b7;KvIyCWxXswb}$I|Ok-f!
z2Xe;KCD48v$Qkf{8mN1L)K3F#V`E^D4gxL6=UNJ0gP#bx2SWk6ARlsP0b~unkUj&0
z#8S}Y_fn|IPLOki!H2qnJ7}sPGeALQzm$=|YbhfGD@X&YBIvMlfox_5hKQw%49rO|
z{h(=P2I++$A5B;a?I41tdcm$0Tp_Ll+7SlftQ1!TaTo-mxEUDcflOHeGX>O>WDv;Y
zV_?_@5(k|V2M&IaI7D*@s}e-B1``7V=;(K5(24DEMUbxNamZ260-(!#L8r4bgO*XE
zsaXv<?o?U}bfmHSGH`gMFbMi1A8G8*s0Etd2JaLU^oJg4EPV>(Nzfs9;Kdb)T@vz4
znxKslV0VHR)POh)0-yyipfm27LB|5Z-2mR?C%9Z3yy9Qr7!v~n=omoez007{0rD`!
zFAu>hd>90Lm>C#OFJok21|4AtH-|wWjfsH)bYdy<TbN#OR0w#mF);jI2D;8<Ig*)R
z#|d6!)Bpt{i~~NZ8RE%Hi~^u#0nw1n6;~MrK>lZ7Pz4zdN(?^B85weyGcvG(jAms4
zu>?Vc+;T>SV~pC%85#0*mV>gfKo>IuL-le-2Il!N`$6u4Sg8%!&H-6`pv|ZYwxp49
zr6>b~$YK`O!(bCY)-f<#fKUvKb6&25?%)8K0~LjyNUO*x1vUaI3SJy6sK}`a@(NT8
zq%w~|P?6ILSrFWR7g@m~j=XgOBDkJK1av+&Oglty1B-MQ=#FowC`520izu?~5W!8@
zRBmPgAAJke&498J5hjQ@C>G?dV=EXL7*SRtvUwt(dkfbE>w<`EV3F2Y$;iMMj--qW
z`3y@?>_D`^^a%dvkU-nAD3*Y<Ujw3AWCx3UC&=U$Bq_#nWKI?m2VT0if{*M7;izTc
zuu$Q!P-9>)_xFZb4KbR5L1Z6`3}Z2pFk>1rClZMRH@FXMa42};9`b>H3<5m-3=H2_
zGBPmptwKuskmNQSvZtIuptzNRL1q;r1Cu^X5ol!}IA=jtF@ZFL+~=^0k-=>hBLgc)
zHG?WlID8c&Lo8faz*d%lAsb{|Bg{C^NESE`3#Dj*_PsNxf|P?yoV1FOVJ=83NCRuh
zDn`&Ez(dUp41yq05f0F0_JS)`F)|38Zf0OO2r~69%+$p&2FQ_M*RBKUSKSOE85kJe
ztzu;O2{Id`jrB4}RNz}P0|WbNMg}J3)zI+3WeP|q$b}}W85!(XGcvG(w6RLA2D^|I
zw3G=XDxiCsfgu89U^dJ^R~Q52ECy9CkPZe0hMLuk3{4<&K&lbKlUFk`%!CUIgq&tz
zSPn97Bg_<#aSW;;B_P)vTFuCC0;C+Ih(Vxm8w0~Nkn#sG<)HO+45}a{AmtxdGctS!
zDF-QHkbVy;uNBuIRZ8H3`-n1hFFZ>+leURCXkB9MX$A)UHH-|*Zfl_7RMiHq7?K&-
z4l)XX>NAE$#ylwo29Zuy)~q#%tke#&7c|s1$8jCbVrmID_>@7YQs|!MURH47!!$7h
zvd6g(#t(oLB>fOROcUhD><O&gpxcaKf`kf^URH7bwTx&5iP#0C+zK&Cq>t6a0;KR3
zvXmIeOArMxQly_%JrATXVI3k27(<Xa1kbddz^b|!WCF^vUNPj70b;Vq1Xk7GAcbU=
z4k3_%adXg;TA1S@w8$h@A;w#<!C_F;okik+hvRggBZ+`kiOQU1U|`N&2WtPJ+<|cz
z=?;v;&^s{pEM#D)UdPD5yks3TErFJ$DuEZ$_Oi(f>N7Hcw@`v>TJC-}&b;X$D_lTU
z+*=1tte~Z?@aq7;Wr@IPq_wc8EkO#P=l`>9V_<j#vhW+s!W*D<q5@Wn7#MihGcqun
zt%sTlTAB(jIY2G~*T~#6ST#VRFpdL=16kE45WJm%!DT%o15@~Vs7FBNg7ri4I>=m5
zm}abJWXN03$iNCx%^=Xdje(&Cq;C?kKJd*8+`qM6fZV1EQV!C(cs(P-I*?Y72G-W~
zj0_CL7q&7ma7Xa%2N`h*W&~&%ERxkAJs|y$*E2G_1nCE<W)LWQ&cN^;q>pO@)XAVb
z-;nfy)PnR$Z(w9l+`!1d3R2A=VEvqdL4N}y1Cu4PJ_c2g5|DDQ4U7x{Amt!M4ANzw
zxa!&f4b?qb&~yRHnXtG52}0T6<+hNE#RT>(Wnh@GfsuiE5zHdcnp*||?&S;&8$b>?
zj4Y1iaFBYCORj8SWVi)#2}m`AfaWp=h8G}xpOE!2sDhM$lrwK+WZ>M$$iNCx#8BL^
z6dbft8yOjxbT>kS2(%U#$tI9;kXE~mj0`RytsvD5(knoIuG<LpGpJ_+PM@FyL7@JW
z2MI#i;MKX1yJiGxyBHXHHZn3WPlMSATB6G!aH^YuVF}13+mXeQTmn)La><E}j11>M
zE&-`#5O~qWz;Fko?-{Z_233#}kn-;v85#b9l!Fv86uWnU{mi$Ck%38Z6V%V3rMpNr
zfs})^8f{`^0Bwt41*v8baA#s*09_Kr90St_YMz7d>=ZmL4{lEi^e`|mWP!}?fvHgt
zgC2V$I0f9y2d8|&De9`AqcK!LMuDuFyNQuu?IzGwkRYNMMAU<>GH~Wl*u}sgeG3%a
zmp4IE7N|!7=^`czfY=NIi%v5zJlw>{zzn+o0PGV`%?S>Dwz(43&7kv3B)J(FK!+AE
z^KXWF8{C2x2;*X405vU{)ltO_WEdFiHiH%cZ-z!QsCf%E9OQ4X;evmZK!Q*<<iK2k
z4A2d6n;99HCcq3tguz6lFqo(V>0u^7ci1f4%*e2DGb00Q9*8Ih5zQbef%}XM4EsSY
zISDfm<NyYNFP9h?u7fOk1rrAyX##d3q(}m(2ZiqM&5R6;TR=ztfz8`_iGhKC3nK%Q
z<Q8a1fb=n_f|P)iYi(g<0G%Pi3R1)%u!f0&0d#siGpP9tHXUL;=z4chwZ)tOGX@f%
z3Tqh{^0qKCFt@_QLG!BMjurPJW*P8As=&f^3=ES&idLa1s$k$YVo{C-t%w&mw2pyc
z2T0L*OhryCat$Cw&KwP(6!I68LcVT+rjSdJi(J81;DFc+0@5287?`($R>p6I`WfUX
z27y1U3=Gm+85x+2VB#Rpfhz#Pt&sj9gDUS<NG0sNm65@3D`*Woh)@BEig2t0P0NBr
zB{`mf=5n{oGBD(VY-)j-7_t@IdMaiR>R?icgy^c1V_*;jsStQA%fK)fq<%R}eHTcH
zw8A+C2Il8mp=l4)=z_P`z>LRw(1x4fW(fmO!wur-EfQv+PA!8ZhfE6tgMelW1H*5S
z>4Mv!{sy&q!I_rjfIO(YVh||fW?+!t#>l{|2~z`!$b`uZ4CWwlKbSaZ;00258?h*>
zf=?B?HHCp82BatrSrLQ4V|E6H5|H>7m^dO}XE1?>KA_#}RZK#ltF^!_0KwHvJRpxj
zIBS`BKojW<4ARk{!1%I_h`=~6ZVU21Brq<BLjpq}h=YNFX*(kWv*~tdFd$rWhe;t*
zjFAEAn(s_}pwS431AZ`p#{n1^1hz{uFgSw@NQW5!3L}Uu9NZG1(hr=%1v$7OCng9m
zi7_ygf^^J8)&c2#`9pf@5bgfZ9=ZSr2Lr=$kdA#Y9Uw<SbnIu62bDAo0^D*83}?18
zGBCY>DFP)gaJB?xdN2dh6#|(8%FaKxGcx?&&d9(D(#D_)6BgLP$RM@@CM;ks$H1Vn
zgOP#BcLy|tu$v2ZvydT^9;7b^G67^s+zv*DOps|HGg$3+fSN9GvJ4DDj@(rsQ+r{i
zg1UoXM}l0-kPgxV(!T+u1H@opVDN&{jC1zxW@KOl>4%Ci@WIr>1R%6IgaX;N2t!LE
z(hvYt9RuP}Od&_^M39zzBvovn(hsH-lJ!A6SeILHA`|ENUHDE=LQJf{24n^Au)W`j
zc7hVhtvZOI0NC`3;AN?OAT6LW7GymbbCbHWak$^Z!8H>p;t+8K4lK|<-ib`&jH{58
zaGyGaP=$ymxcY8B#v4c~xM6iDNC6^_Ks*rU?3QB$Rly)O40FSVMnD3Hc`w*0AwrJa
zjNl;@kTe4WLjaTp-EzlNY=M+C8T_F`JD{~qAxs<@42b;lU^l`Swonro=gi-So?i$i
z{y2~p5)=QKy(B08H+x7<{JTL~MiW2MjWigS&<w-GFK~Gd1H;;Vj10_2_CYHmQ2!iU
zxq_OH`k;-f0*7WZFkAvDx&u=rs}CBw+Buzp;nhAy2Bt4Cagb&PRgf}JE@9oz$iTgy
zk%1MYh(Uxya6co%WJXXcOL0FV0~3hBAmH1=z@WdMk%8HDKhy=FHWRp!&yu48(#{|~
z4b&jX-;b?90<Ixh0-3ZxjWP!5!yuLGv8qIC#~ng$x*Qe<UmVXMP&t!<VK2xvk6^9=
zc?r@A3t^H1ji7Xb%Q5aSCPDBaP|h5`cQP<Y{{vafaRAyRPE`OeJp?z2L2L#AlbH+*
zVh0!*m^2SSy$LcHQ8%lC^nwD->Hs5y!vRJHR*-52fxJZw4B;Ss9S5M^FVRCX0PKBk
zc_s;vD2!tO;((_GxfPh?AzPzCMuLoAbbygzJF-!%Ak$eBKsM%rh^hmisC}`Sf#E2~
z+8Z$Ef^J|$axTaWka;f;FfzOc=>w@|5LmmJf#EMmANxV5D?$1gR6$BW$|VjmGRPfd
zWMBm;Vi0It$-tm<kdcAO9;O`BQ9!Z=q!y$v;2<MI7)T#THG=@#3I>K0kiI-*eGIA~
zB_QSX2N@Y!LCQgj7z7;p7#JpllrMuR2eqw{tO2P7>Dzvgkzp@LA4oNWz|kHChSMN@
zSCREGsDhM$ls`Mj$nXZF9HfXrU_UDZ!!M9>mP1g_gPN2KsvspG<)Vie8Ke&}GO&Ua
zF$l!UFfeEy0yP4Wl|x#fOiW6k7AQCp1(}#kA)Qx{W{^Q~hZq_1Kn8)dvl@X|_MmE1
zTJbys1M{3i(3FB0ZPsVf1LY5}*(~}@jv%ucq`g3@K{YfuYamqrXN0LvW?=cxXa(vH
zF$fsxGcbTEYo^yQ=Yr;MkpdB963BIbKz=&R$iNCx%^>hykAXqpFe3w#)M03-fb=n_
zGC|u3+J_k#K-Vv_f)p_blyNaIfUa3&2F*EvO$W9883a5<85ltGOU$537D@aNI|Bo#
zMrCS(84n6{umW(SR~4il<gCeu85uy$7gmsJhT^@T_DVM&sI|hh7p4_7c7UW6q#UI6
z++jwBD<B_%R5J)@iZU=fI?Twx{062E>_n@p>WmEBM-WYg`yjobQQkQUN1+4sb2Sjs
z;3-2Ub4^u9w+o^;3`8-RYg&PNi;RIVHGvtR$pVlZ0|SFXSz-<YlcgpHIAUOe1tmoc
zOjeql$fm*1HI;{|T5*JtK_QcY$xc%OWC2u^fdQ@%bkQwH^deND7cPY`6MsP!Mx!Z&
zul(`>83%H8CIeF%nj!|PRqBik_D2zcA^^P~k#WwXS2)A0NnHimmykeeQim-5hFS*`
z^a(dbn68k;z|^bG4jL_mDq{ejh<D=*BLlb-%G9sU+pNLJppai$!oV~^oe$&+m{NEk
z&4Y?490!GF9s|>4b&(mb5Z1u`4p*4Tz%*4|5;@4(Km$2YbC4+5;zFkB>JBl-7#SGL
zk**SC1da5-72_}gwu*~sy1M*45==liA8x`7b@>PQP2fWI1;PYauZn4=x;!2qAf>zc
zP;V8VfClLTb-sDnf)u6@l!_OT7Nkqm9o8SGC`gy6%YP)n1Vn(qgLJ97yzvRVZXgt-
z%ZLrqE6^ZiIt2~Vwd#CJumvehAt*@KqXwxMmos`ljA^5~=O2(4B#@*ab61K;A`A?K
z(&t8XdApN%g960_EP=U6UA}=V6X5A{v%35t{3f782Q)-MI|ZOjrj6>3#HH{#P#vMC
zq0zBRoo^Mk=zu8%MaLf0=s*b&sCmea*{AL>@f7hviZB75KKH51Unao>ERnKbU0(Dw
zUN@iwDZ&JJq#PhNg~vfXpmGKpq{r0-Hed@<m_ksHo**qqPpLaRA;CLP7a<)+#dL~*
zcfff^Av2GG>5{qta(x4pU|_mTnv<`pn@vAMd<<Z5@>K#(hSZvTS75c~U3K14c&&L)
zoewz@Flx=PbI{m&NJOpqm^80HRd<+l7O&TFWFdG4c&aXcg#;52$ro<IGj(~fb9miA
zC<8nv5d82Ug;j<t&qIUs9TBzW2hxJ{le)uG{N5oHq@UE~)z9M%5EK)z1nFmW`AqyK
z5DL;S#0Dv>GPJk|4btC4)S7=$gA`k>`Cr}B=mH}HBc-+Ge|7m1kU2!Q3$X+ygNFPz
zvP^&%(2N@LKk%D?5*>&F2Hv{;Pin2%eF+*J92$gcO)d?Rn%X=X4#zJNpFR=ZfoFLh
z4SCK>#G8O6Qg}7wz44oX5~K(d;E}?oL1a@Kc8+({WoVF!X<)B4VG2RDrZ{OqDyd;6
zbs2Afpm+xnq;T&@67UYRa?E33QqaI&YbuiFWMvJ9vy?emnShfawdUKKu<oU{1`l!r
z5MHXMLW9HhDl~$0HL!OtVG2PJq(_=>4K(a_U%?weC}lF#MGOoK@HB6rA^#V@2`EvF
zCB+&N2rqbmq(QCsy9Nyq3k~d@LzqHPfLM|iAl4doXRcBdAl4f4eAn=rKqx?Lhz*d5
z&;Xfz9U36c8rZvbFomE1aX}3bY?YLohTC<J7f7n4z~kXy2f@>Zn})pPb-Y1=lDe>@
z4R;OsX#6Ii1SZ&eFafV(+%)Wn>zILu+(1jIZa@RmA4e4fQwR#o0Mx)l@ebG>U;^%#
zAPqCE8+Zc*hj-xRVGyxtqX29(1A`@~oB{PJB5@S&FohuRM3Ls57!CWMlzAtHfOinZ
zdoqsVJ%uzUr)k))xk*tBq!Dm3q<DXGA6C5QY49Kqx4=uYENBFY+=iyN0vyFVOd%+O
z3Q6;Av4;JuTX=noBgMkgTd{`x9sDM6>7fkwKz+pko=gB8&sVJB&g$yS%)n@astz6y
zxlk>#cc1}LjiXqHDFg*X4QT;Ur(wVNHbntZry>6ozX>=30(O1{Q=Ntz{(#7X2E-d!
zK(ym1&S45c0ntHPKy+!Ct+|6YAPAK}T?EoUJYI{S-uZeL8m|*^6sRzTAn!~f%{x;x
z?5pqM^$wu~K1D-*FMbnn#H$F@drVUZ#VcqjEJ*Rcd(eQGgQF;hDFg+?T+#w!zJ`6v
zJ&FQizJ~lU{3hTC2zUaYuMvzjfg=j>WjG4)<)nFbrG|aseTqE0QbT?-eiI0Jb|nta
zLW+O)r?BFGqXy4Bq_IeN?toRh(hs4DVl$57AEpqLD7KImPTMr>W<DS%oZv0EZ5r~o
z@tc5BTwrOzZ6~(4hyY~~1_p*#umIVQqZ)uI1O><e(gNg=hS{ozcmo8*J5U!PkK!I8
z);n!b&0ilu<M$+v!W^a$<egKf-oe&3KcnGZ{D}MkBzVPsMnirp$Q;}QNH~H5-k3e3
zVNYDkIuaTbM;=3i;xdkk0HzQW6jxA#0!J|pcg!^nhnB|_#q2d=W3~|Loykw2-nomT
zIEN_&dFLK!-g%&5AN+(O?>r#j9Ymr097m!2f;1<;(y(WHN|BRa5pXi3XiazpD_TEk
z2q90m!;97+Xat!&gGSI-97U@?R3RvWzLDnJ9~x#~DD&+P0=|WN2iD(Yeh&4{e;frP
zOd-fS44Nd3eKKjf9ezep<S}UyIqnE+<nX<KdWTaJ`=A9(A;>#isNTU=F!E^n_B^LT
z!N{X2e-300`2{17rYms;BP_!1!h%9r6Z@z(Od%*JL{Ni*P{Ams={ENTMKLQzY|O&C
zC2L+nV^&rZ`-n13A;>#&q<Kd{(>3QMMcz>$;2lK4sIG~9L|KD0Cu?cC%D<w>$yx-Q
zj5tp3(Pu`6idWzhcbIAs8!i~8LszwzF|aU(Fd8s0h;V?`H;HgazXq`*H5eI0IK07R
zI+z5_<65a|Ffv?4YP@DaSJpGm0oemSz!GyMn~}QK9ndZ%XxR!`fMuj^i@fRyyxQv8
z8%BodjM)rKUh0CNrC7`p*VK!F_OC&8LMbL6b+i08j0}u(ke5J#_OU?~Frb|13KK-o
z+_o$%Ctrh(q{VfjE27y7(}n8@R58#gzA!})n%kU3&Ku-DGVU&bSPVXlkl4EmU>jl>
zK-ZSAFotr~Fqo(mGbkyaU}a$p1cf030~ct6AH;RYB<uhzCU139#)HVA3EJ=nQwg^K
zbeb>=V<>+egON%dgA&A+4XiATA<PpufX;FU$Ks-Q&{zz_AB#cirnc{hjzvhoz?=l4
zL9y8X7GEqP2B1OeL72o?6a=|%U}90IjDbTzg+oEjR1Oi&M8;;Yx*74Y$y>t!k4sRB
z31ObN1s<0nAE9v>g+DH%)lE4+5FMAGm_Ws#xQu>}FD|jfKaN9*apcImAmayLT$*Dk
z-(u9wh%DQ%go-T-%TiEO;5^=$;#{Hrk&%IMkc1>C#X@rhVy*H9XyWqx#K@qK&A^lZ
zNxV=|1~vkPVWPU}6Ob2)E)aQZ80yiA!yWa63*96VvnkvTkf%eKC+-1dQ+TJq9_qaf
zP*3No3xn!Vs3-%DzB_C`98;dU0lp?G+!}BZ&%nSS{uvUsg+y5cyC9XRNL`;OYh0l2
zu7g@rPLwrp-&ElD4SXH8JJcFbDyb&TiW>YrVX$J*U}RwYg2<swP`eoCaDT<Qf?ZzS
z2zf=n7--uvR3DUL(oq-q_=S;yal>|m*^Hna%TNUjVxZH>U>t}V!2?VRhe4VcKxZ&P
z<rqQ7QbE}aT%ZFPU>w+(5aRqV!TGFmsAqp6t|7f!3T|F97dJ42+mbAdL7ec#!7Pjs
zOdP664bN%c!K%U6U4k2)R)Ok_3|e0y4h6a38I;L5r}-Nr19-F()Tm?(g-2TiR0XKJ
zz@^TMoX*)m#}9x^0b!^z1_lP$UGq#*>RRu=GBPlNjv)Xk0bwrC`Sc(LDu%UtxU*O}
z8Re%V3}XZxSPxTMrGq2`)1s@3B*?(Pz=iB8L;-9AHH1l8U7Hvef$q=*X(7QyFfHgV
zVqmb!RcB;a^bO%HSP8;72NXvbjd^To@vE9p&37`=qCZH}K%_-RUz|zNoPoirQ=O4v
z>vu$u{DLwW=j8D*F<=A<q$_hpO>>?ER3YqieWn{~5|UB~L2$8Y&d3BgXp8BAn)n78
z1_q{y4s5VvEkN;#P!CJ$Ob^u5H2yF$FoMsy0I31(8v>n`0cA6=fzHE(aS%xhCL*|<
zQN8{L==@>OVVN*dHqgZhFb*QO!$btPGdlYJWMp7$KuX5kzS#)(LHm6$4WJ4k-kC8R
zNd*_|%ubLR%#*@-eliL$f)DTn$%76h2Oa6j{SE2Rb=aH(Q~?761818OBX2&ED_Ec$
zHqenRFm;IYfMFsa|FnSo13JJ3Cdj}BJNE`80vk7GV1Theni798GO&Wqz+nWPh67Ru
z!i=E9bwCUd=GzQ9A_v4`V1UnYL%E=>WK(6n{bXcdJqA+6jT|PhSu$j`df+on89_k-
z6GjOVewZkn=4?}91qBHsEGVEdY_MH-AU-0*Ks*ozd2SoXbD+I=+{oMOF_REyw;U^E
zdp#TI@EMSH5Jn^$SVRf#U^IXIi;)5K{6;p=CO(h`5XRz?9gOA*zZn@AL7V$PO28P!
zCa?$!A-IE)GZdr=WoJ4U=nfH>I)p!9X%(c2F%v08GsYrwKo^R@G{dqV157VBKT^_$
zS8i}=!T&6*?%9kCjMhlX81<1kYDgRm<6-p%1D7kLb}WawgblV!5yVFX9_)g2Q1LM9
zA0q=Jc<&-e4FdxM%E1|kV1RC*V*nkT!2!}^ht%Qc1D)gw)z5(NA1saq@33k7#dmf9
zOd(Q>;j+|sP{D-~LpTo3fLSbvaV7W&JvajvYl1``oB>x)+`$<z<=76+z>(r$H-3Rq
z91kNC$tkXifr){Uv=le%KglUB6QpG{#rYsg3Sv*IfY*9NrZ~8I;!+$;Ikps+2+RHo
zj7*U8SJ2L50bLdu!UQT3*<hQ)L0S-=1o1$a>6)5w4<i!;c*{69>?Ad?42VF%oXygZ
zqtzJ1VB6<G@{ocIWYA1zCI(i}_IXCoMtYDO2s47V)`J)zjMD6YRTUr!2o_{!()<m|
zE2zy5*imyJMX;(9soBBIq`8KPiGdY#>>MNL06LI55M~4&Ne5zpFiKMbcD@lv0)ho6
zDHCW)V78KQH6^$}XYxUeWk9MMU~LgW7A8){V9=R%P&JJ1$Q;n=eNYL+QT#By+@Pz$
zVX}~*2k~IiplUU$osogj59!KnMkizr=!S5R77&J4t1$iWYW06OtXgGZ3_<Rk1|m2h
z6BroS;z8%WLD<j>lRzA25CK}ecuh@s9vc$_V;QnC&`EPp1q@u1ks1{+K?Vj`=SrxP
ziIZ^^k`hMHm18h<e8|0Um>_}{I?UwF!i08qE}tj#zyy#wSji4zL$J_crVSuHpfeI6
zA`A>DXK*8GdzdtqGr0MtA~jzSDIGT8B6OI^mz9ZuaVL^0#x=;C#Yh~KBZ3iK16ceE
z_OV(RflQM{N=I0R8*ad+uDDZ?3`dj-u%b`s2oqxsvWj9P4m{1kRO@yi$?|RVL<A3(
zusz530_4!+NU9ijBXJmTL@3OwLg%?;K&c7Er+nF-2u~nba6K2e8bNw0kyN2XD8ijE
zErMK}=!dGqv&I}*25_MZng|R8O$35kkl0(Duofh!bQItuy$w*uL2?^l9y=2QBj`#2
zSlUE6t_|itlvZahNXuv&fQ&W(ER2b5b;8vX*9L$o$JPcw>8>Km7nl}Mic95Wf*c)#
z(p^OqA279u?yA^V4@B;TNHe`x)7=kBx)Mmal#vIS!;Hj1ITj9-Lqb5KoD2+XptE!!
zCL)vY6~J%RG=#XA7#R0}PTzs5U|oNR5mAcST>xb}P^*T8F_6)afq@Nl@+ed(QpF<%
z6=Hg;rtt@4<W1y?=L`}DrBp?f0k9T^;0_774v+yTWepp0<$)+`kTtynX~J21V6h1E
z1_xN#$^h~;gBa+DBB-~ZJ_Y&Ch?|Llu@5Q07#oo|3@H5)m~IC6LI+R^S;C92OhWh$
zR*r#s!a^WDIQu0C-@%F+!8>e5Jow5aM2drJxh%y9(lS~mkx?eWIu68^NpSVVl}Rw=
z*vceWmzQCI4>QAVUU1)p(F301z=`=jSQxcQ$!LU7v(kr|L68rul?hyaAljQOjL3~o
zxMiDsm>D#oI*JkLn*k*5h(&z24>Lm~RJ;sna2uo^bfZ==0|P@BQ?CglLmwX^Ijchx
zC*vFm5$M3S9MXA6kb!MCE(4C&h^)2(oP(G)bHR-P-wMGL!X=o9bY~4jFqDg5*a)lv
zYyd>Co=X8_9ascDQr^HNh-?ddrV%y;*v=0dHIL*HTBO0qz&vqBJv_LM_%JgR@`D2y
zBo3W`LJC<H#vqi1PZuBypO|YNFfc&Yk9rC)F+kjx$|V|zF_NFg#S@AY3J{g)T#{-S
zDhs$ck*A{IJ^{}gFfcG!2rw~BXUt4tU@GMjf%yd95Ci#yg)tPbFVM~@Wk5P83D&__
zEWiXl$*Yx13VDGQJizYyFf()tfC4Op2|2w$7KDW`8n7@1f&vUNo$djRuOCp8`|+6k
z7>mi#;1EYM6n6TTuOP&^Q}GyTA&BW*tcJo|x(I6MQapzC5^E^TrQe~3uEAsIBLaqE
zn?v*B5;`cvMEZR0WRRwTm_uXY@Md7Z<`aJ|p>AO^d=d-NG%!91Kq_HDvz{x2K}jtX
zK06K1HXzBPxFkWx_&q_A3}P;xz>25@-n?UC_yd<lv;jfdAVo9_V-R!k16I(=%XR}s
zhU4IZlgXBg&-)ED^MPjApiIU&Q$?5<N(w;d`q^@+AS;0sPWIReWCt!j38WGpUhKRA
z=gv@2&(A8;gppy32)uY_h=<$wN)$^i0kO>pwWP<EFm$<umWYy(Fv>uh1}0%xASDdY
zGK4*%u!O+?AFsTC5Q7IND4oFK6tcX*)r66OQw$NPi{XJ9A&xUpWe5kVIG4~*F){-6
zG)U9H1gbe&pbCn^0~Ovy_~yfm$T^_Uw1z7JSMG@H!{o~h8o6LDdjJ{;VlLjm!oXmq
zXu`-)E{+K8^H3(^oLh2OLL1tq;X`lJT;jyie7VetazZ2|`QPLeF#iCJQdo=Prv#)@
zd(Me+nkKfa@s?9;zXTbvI1!|2U}6zDYw-IrGhCN|#9|!-13VUGe3=mur3sFxK&Bd4
z_y|cs!sjpH@L}c>yDv#b_-q7e8kq1wPUWER`7Vh)eBglv3LgeG&_S}WbcET7WV**G
zT_MH9zz8~E7N!hk*bmyGN7|bx_!;vqMJx--9&m~{Ns|%8A|Ooz6U6Qe1jFkar}PSt
z1F0WgKR88-WXK3F7m%ib2`>-q4Yre<LN>Bw_=FFnX<&R}f!!xpIfdBd$neRHf%Aza
zT4g9F2Pr0sk&00>U$n~51Fi^E8Cs&&l&L6^1_((fUuK3*uq0~7n9&fS22@fl1gi;U
zszY)bNbgawIGSD~L;(-d3u^R$Ztu4GYs|>-Qx00~GB7ZNf*Z3842*M3l(E#nkXm#J
zYJCguI>U~g4wZ-07+X0}R(ryWP>>54#3H94tcBRhw2_nNiXsyOV>XhMIr8)dq%37R
z$IgMWh(-+a_8HJ{p(DsFl;J|qRmu=EkV)7Ow%}csH430~xeVeSkQzqN^~xXy2y=&&
zBFTV6z!<LokrHDCvWjeEP8<@4>k!iD8X_2A27&J)e~P4p@g_3o0ul!vsGz&ZL8r(f
zuMI+&44Xg}yu*fjh6b}D6TB?N4+=zLMnhqa$6Oc0F!(Orz}h9A&nYxd2^9Y%F4isp
zX`*EbTZVJ7wh>bK<L}FiXw!l67(8u&IPlJKv@bKmJtc7Q#a#RVsqg@`-+x0SAj6-G
z1_<*|TKb?{cGQ%?MnF2>OdK;1N<p?USZy+4WC&J9q`))*a9&|xoMSr$OUVKm#GK1v
zh&&Dk6Li7ck~o(m98={yY})5>_#mqUZ^mVs&jDV#&oq$%#`gf-KFKtZ1HxaxVH2;w
z$iOsF0NUwj<b-<#QV1^Mz|!eh$|3a75K%-xRPNwF>2!c^>t))>!M{X?fq{AAf_j*M
zC`6zEE}#q%cu)s1XBUS6vPWQoGMIvwIZ#GvAu3;B({9L#q7vei3{DPE95GK^PzPQL
zt*j0kb6w6MG9Pqn3?wR{1F<VOM0}A7Y&OAdh!B7(M535ha_CP{Wny3i-Jb^&N7>MT
zsauePMHX#C14;`Vp##>gW?IFe@C#%M&K4y+IvHSkh-`tc;}AKbMn)+y4WwycN(ncl
zT%O^}%<xtXoOh9@H$oT<L35i(?GTVcPIZt%xE#j733!$SG#Uj?Cl;2lbh3|w=P%MQ
zd~7;Wi3%%-m=1DC&QfP$VC@Fov{wfrK$ri)?U=tDybK7GL(ta&fyTXqK=ZKJI_U>E
zRI4=b#g94mEjNrf;|ArzYe>2QZL!e=*@AN6H5>AZAVi{srE-v_IFKfkSzWk?VOw)1
zE~p2!7Y#sbJ3yB&!n8wd2J!Sk1Oo#D(_s$jZ#qm2jFCv;%jkp50o}j|Rn5Tl7O7!_
zsO({;3373pFv=}QxSLTBnZtt2`Hf@}$~r$-W`fztz#w>;QKdu^+d4m3ivgh)vCa==
zwH|DS8=(+n=t@l{21eA?ddQmuU`-wd2H4JNkft^*CXzM@!1N+nJyk{;WC-Ra0ob8=
z$Z82~5&&ORgU|rkH$m1Wfy<04w?XbAX_G*eHd3srLfxUOgCvNuxE~R_uvLtL*BDuh
zw3*Pi5#%D7fJjitnl^znO+;4Kg3PH#;-J(Hh+F_SO_z}ey>^&~)Y!&i|8+(M1yH^@
zgsf~UGG`4E2fpkKW~1(TBv}Rqlr@*oFa+%*gE9rLGcu97<`S0dP}W=`JOYy@cg-bC
zKfLULuDN8Mc%T;QY6daT<*_gh#A>F)9P0hXObm?N$VCk3mROiNHtgLGSilM1XJR{|
zOWcYKxSq>WlR;XD>4U(Wf!PN^aTucPgB3x7ubG%)_3$|ik@VquE=%cvv{2@-Y6)mq
zIvFrA=t@F4Adl#(A#vDBkxE>UECj;?iIth{7|1a_NXi(SkvI%Ew)Vh%!^X_^8)O3N
z)}D_@JJBGC0Aw-TS~g}jTYV-5Mh+yK82=;bVPHFp%mZl#W4H<I%xv`_6P_R`W4w*T
zVZh;axWl=anGb?Yz~gmfHz0fg%LRhm%*@ONObm>;-N1!C_+e|81^Jjc7;)RrfTLjm
z_rg0SwsMdIP#OkeqDX-X4m1YA_e>lihD;2MmPk^JI>;P(Bo5mjq~&oC6F?-~+7L!j
zQIKg0UWgpQD2&WuL*l@@lc4E*1}<qIBuyY=!5CIm3kETYGa4Z)QAOe~5DbwIOl+MX
zr=f%hn+0fN9@riR=wdVw2Yh8BX#3s=Cbm)|CI&`-WMyth96sdajHM<y%ft=Rk2^J^
ztY}4~B#<jWSn!;@J;(smA^|z1K&l`Zo&(N_vVsDN5jB9gCLrYjgiV4F%?yG<%uI~)
zkd$yChYiAOaP<r<oJ58TB3fZhD8aK#%AjJO<Zywfv~%*|AOmoR3&Mvm>jklg3j^xn
zLWDl}dd|Zf(u`*K78fEy2c`!!T9|K2+=6GgpYE{rn~+>%#DTP+1_So{siE=AfLWD|
z&~0|`03mYI6I?xUiwj}OIkDVNEw%+|NCUEnndu0J@N07>2F7PdQj9l|IOa)6xf4<>
z3SJTyV{AeaW-LYGpi~mD(t&{i#u8j5E;9#|u2G9b0$t8k;xZR8HF+ZKLP6vpxJ|3Y
zb<IJ3BVr*jTo2|#VjRnr;W}1}>&~Uz7IS}ZScw6v69iX_>oOK23#TD-B9S=oI;{^<
zJF%r9#ULVN;76hy=a6c*U}9jbMOIdV#Nk?j6r+fO24;ZZb|z`Y{YXj}w;^%h&2jyF
z=-5XCXea<Q1OgfiKz19Z(M(4<jFc^jb{itl$aUL;I`Cm)3qU8^z+Da+`~}S}!Iuy0
z3V{s@-Q*BL9;!qc!9#clmJgY3aY*k0c?ahR9>NDOJ=jL@kk_w6)G<Be5dQ=+8PEFl
zw@7RC5y=47++%vk5gu;E#K6dc6!VO~k@UdBqqzmNbpX0XjeFvf+9@nN|NsC0FU7zR
zi|jO5O~mw&BYCM669X&Aajc+4^>Cv=>+wNB3%=VPdF(Eb(T0J6ji8fDxva@?@(LoH
z+!|?3qLZ08l!$Tj+I?iXc>xh_KEq=}qMJb@jyQIHz?z^;4>`{KwP9jlBz5NpBxy1*
zfOdW~feb(`<&g_)L{Ai1(+iL$oCP+l(E`)Kz<_1nAeNMdJC&YswZ#*B7>n!~#QKr4
z2P8`|J>pRD^JZdToQou7eh6v5CB(Tx^-PM47m$R(hkWMWoX*I=Hzx;T7DOdFDYR0+
z%8rSFaTSs(l(SASH46%HDiS#B1hcThb=C=AG?K-Lc!Q-Dp_Kx>4onQJMLCQNjG0JE
zQAR(p#N9eZ&E+6}p^koH->VGo<*sAYjIbY6dzF#9EQpwZowXvko{`ut3nE64x-8f1
z@eWLIBX`RXw!=ajSNDSt|5+`Z-Ry~=C?#nWmd_a}?h(lZ#u8e^G}VELfiVzC6$76(
zG7p~c;d<7Jp9JZ#L{`NojLgH-vyS60NRJ}2D!$`LTWk@*Bnj0mw2otu3ljt57i3k>
zkvaE}IBZH@2qO@Y1~rR8a6ha4T1O@ZMgt^eTrmy^Jy_~|Z)QW*Vh2VB)-13(w)03^
zZDElKvw#6?1&0$81M7QFMh4bro{S7!E?|8SC6LBFgbg7jB$yRggTPAItdN`qYsNxU
zfk=?+vz?e27(I}bp|~EFI6<l*SkRhT38(8}`<)<4K_tkEW4K+9IRSy>dah=qfPv*P
z1_oF}f{bQ7h@^yZ3lfKQIViYhc``CEPDBz$2@#M3QL&&0hfJ+Az7RpgEKDbQh;U7B
zLnuN-KWwX|peKhE<5eUjj3<yeyOBBTkU2|{IBdw%1+W~%fH*Lyhh41!l*mb(E`X&z
zl<5ML$qbkZB)c3K_0c9X5KFh<GlUOn!83%A8CwPh29%7A2rigcgf?(o1G%4=jI9QZ
z2%!xeWggVb*ln&f&)5%LX_m2F-0&r1s$}f>Za7^}PR52sB&{-bm^;1@K_o(GdSW0l
zV=F+_(=ubj`f-9i>}rvqL{4JHhUuqS#s-A}A98me5uC8*oX}=2K~JK4`-r+0rk~W2
z2yl_ZTy_KGG%n0FnIK_UA69Sz6FbWKOq4^;5MF_+pUA|y(+l6|E5iA(5>xOF+f9)7
zk&m0;Mn3TlQB}aTT$VyT?2ch{BvqVo71B^3H*(t+5$2${1z|zTM^YIWQ0J9F#xgK4
zJ>pP(9!T`OG9m@RnlYexWf>oQgYgL8K!##L>r$j%gF2tY48|krVVr_8_m48KjBpq{
z&Anz~+DfFu;Ce1gwScq`<1k40fjxufF!;RkEI%^lmEj&{WoDD}Wn#cHxk<#laxlmQ
zV&;`$4HiK*X11vyO}J;AaLg;iO<-qcyACn|_na;f^U9Kb_`ObeUO5_M0&X|ZeqQ-J
z$N?yWNjT<}*Z5O&UO5+J+Tfg5eh6|JN{HZ?SB4)w@_~u%YycVa%J9T^mMIyeA9rdd
zJg+<*WB_WBfINT!D+rM0i?Gk14zhXWYEZFHa=5^Y%5(DTK?dLs7etW^YY^ZX*daKt
z{D?y(GKBPb<>SHlS~f6OA@u<7ussjLSCz5A;~E|em!-CWw4esV=)5u{prAWr2H`Fg
z*ivW)(7vtK5YSrdQ08(5Hk8w5Kxd-VAZ_yi&9Gq^sYhQU&BS4abl^xJBq$iPLSeIU
zUpbT<4G_5lvhx2shg6jT=+KsiI=I`W_%bu_g~Hv27>!s6-YFcy1Um6Eka=Q59rTD6
z?Jy>WZl>TVOjtMBD07N1hv8eEjpIgytD#H`xR+?7jH)0q2#f_<d5t!z0uMsipbG9y
zHugxNzYckm&31GS<cyk?;jloq=H$vnS_co`DF?gZpd$>X(vedf`CuKm>p)j^fhPUR
zKrLr1`+>bV#e%}g2u>A{CY&qYX&RhPNV^e0-pdLHCoa$dH}L6rP$Gw?zyrR_3{#+r
zz>}YhhKN)MG65Dq;9Uqx5s=-7S*ZKf;ijGSWoGyWHLV_W7y%Q91GWqYkAhp!bPiIC
zzO9mlF#@#x0UojG(0sNW>WD%-j;M}+_#0$y2nCKXM0W&iALd=CBYN@e!(@AN5K#&s
zY9m-ofHo>MMKdul{z6hlXvP0BMwPTkYOnZT#;7tolE@YR(7k31g3B0HDx#>c;-42}
z$Y5LXzl>4kEXZ9X%{8H{6NHtI3=HtGnB_!Iy1`l>h?^7y&oX&~(hBbO9F9ph*klT>
zwi!wyMI=|GL@KHthcA&Ly8qA&3Qii_G1w9*A``&W;@Fmg2mqKuP<nHS!J9~7J!=LA
z<U}ePOIjj@1sKd?1_r^YGMhl&!AzvE5kF+Lgtnz%PCel|a2n+>P(;+gECYo|5y*3c
zDUp7NC1++B7Utw9QspxVq$ko1aWqJzPeHi_b@c%9-YM*f^iVt%5@|TdkU^M8#S^fd
zSc_S1AWp2MaY;HAlvb!-l49F2d7eXPS|S;3$PAFCfoVg6&frC!gg_L<u+@xAJ2{j&
zQt)-x5p(@8J)mXaWy$!u>xhg2FAeUnO-sVpU56<|8kxB)l?u`_+Fi$Uki{VEuA`i4
zj5WoHR;7`i;$EbZoZ>h@T9Bu{P{t3jrnu{%yfB*LhDC}~g0`+eowGL?q^GzjkRFtS
zageudVlCsU(n&7kJV9DUQydv74wiw5Jx3d^p128Gm~yOJU62>0Ly{TOYYtJRO#J7)
zV_$p@o1SHQ%@NcBGJ*K@@}NP*5RQ5V{EOvZb0l2O#Ip=J6g)VIx)_;>Lks81b68i2
z={3g$(=3u!%R?MoOwhq|YP0Y-7}cqaMhsZjO~2t#YOA2}y6K|q!MAQ2Hijp(QouEr
z%yrZELH<JR`Cwl+4Lg}Za2=!Ogq$I;ZW_MTlfre=e7Usf9TQ$RJrfkABn=Y~UN?Of
z<QEdxO*7_!Cc;tHKoeXyZ3@yu%<@Xua$BKw9JdOoxxDfz$OW`rH|>y*bAckFF9oSH
z7#NUN9;2)hhE+Z=b&w_5i}Ud<CZx*p%73_BPtNj6SVYoldF9pud?A8mpbc#$`5;+0
zy#tiUNnBnD>snENd1V7=%OdFXDCp%`gx5{;6)`a|5|goE%WZ`=aI7n(X2#wJash2K
zwq!BQGImWdzGO_5jC~!q>&eO3u!y8p#_lV@7b0Y5Y<jPoo(M|hBxY>dt(%5sY*3{_
zc-^#T86DS6gI$Jy-84Mvh+H=<4e}=FypxGcoFB{a4IUweuVH1X;2kzWkQU^@qtSKK
z&;TW{QV1S~M4mtaS5I8G9Htyww;Z(k1Nl5Ih=ZBla45^yQ@CzAq!QoA4k87?hJ^$#
zODTi25Hqraqz7$zG7;;h--2vGPNyh?oCt@(!cFk9)E<x)VjKnuKfLRvFI7{xZaS<A
z|Kedoq?PxGVju1sHfFYNkO`!&n?4KDgnQnIh;`Ha)p*asB4XWiAjkyV=V76^0pWFc
zkDHsBc{0cZlGjbc*6dK>JTCSc^t*d;tebuUQb@J)xR!!U8=UK=C2P?`got(1taX&F
zo1P7_6nAPyDH0GV37);r$)5)qfLbIBhjr7NLE%brxWEgSbMntY2H*}CL|DR>!{A!>
zfNR|}?7C^DHylb68}Ut2Ac}IB9?(SW{|0<58<?w5)=kTUwBW2U5R0AQ!EjmX9jN+5
z4TjNm(~#^#pfv<h#K1u8Bn4bOajhYka%`<3l!;iFLIwudG(KqRpScBJibJGsm>y7y
zD{RJ>;t;76HiRX3hizgLzQz+Gk;1iHmP!C=8BK9yOpC!{dZ1GrtoT4laiXPd_);8V
zfD}2!J#NL9;$W?3q?IFg*qA|DaF%hfbcUqmveYF|UKmYr!!5<}Kkpzt#f5_OkT&&S
z+K#V`!<yn;Kw3sq+z?A~$d}q7YDieA%k+su(zg@erFMuK5~c^sfqZQBZ!y&|z;7>Q
zQs5L(?qOnJ>_t+>g}g@rW;O!@Y=0)x4R%x9`x7vI0$P*I)`e|VEvCzGEd55bC1EU(
zq1Ih^mwqE$0&5t6G)Z)mwyGA>je=8U)`Gl)xvCcCI7FBUP9?PT8&SK#bWyPMI~U|R
zlIC=Atg3~L<O`CsKLJ)o37%zo-A&HqHY^-*_JOc1tJUBXc?(L(8<381XIzfN!LieA
zKS<NSEUWcmU_dzm6_x@JSJgA=amr2YC3^fEk>ue+GbEjW%3sI8p`gN{pk}I4%b=tz
z0X}i`0qE*FY$0ySDHPvF#zJO8kfwnNaR=;IB!+MbY4(%hlivg96H5jLHq1NyKq*KY
zM1ZcV>Ez_uGLd@s`zeCVLTSqoyx*^90w_?Cj>sP-_xr)R3Pj%T2d{rFOT7n$2r*4H
zco}$E3T-TZ5H8h5T$KshTK!}qc&8;~Yjp^C{vY}L+#p7zYp<UBGBf-|s7DyI$%mOi
zbQ0JgredTmte|W6^dRCO3lJJW=k-QHB(N?+G)E`}IkFX^6l4ar?WnM|Zw#QVv2!76
zQQYyxmziN3L>y!W!tfLyW`=VR3D7-#aDy2Am>J$c#F=Zs*K#9=19)HUWQcdmkh}}p
zj4KTm4?(_>l+TZu!451O%8PW$v9Sum9nyZx49Q?6sH+@Ne4*jT%+QHN5p&rFq}x?Z
z{g@fnVNr!*)V5cQ3>U$QLLv7VGSx9aPRxVt8w7_X3I`rIpeqhJr$D@43)v-%cEurF
zDd<8)eTY&}I3g}W1f>iH&uwoQ7(n;qd4cwK+cSu8h#4?4NOBaPXJDu~VaUh;y3G`H
z;VDzy6eb4n6o{k|BZOfF+B>caD^&ZZFfmM>!o<J|Qq6DzT(vSy=HSr-se%@<@=%&_
z&b=v2(7O#MbI5qVVPIekh1>%;74_mmhLaG3nmE9AgY?e@5e%S9VAG~EF+eV1Y~oM^
z83L7o-u&0XA(*HM)(#ejnBU65Ct->Zgd8l;$04vt19YEa2HPhmSm^^huN|xzN-*_s
z$Tv*|ZS{9XC}R*qUX=_nn`r`vzy^>)&_UTy%?#iJvl+w`_e0cxgdr@Z2^?j-)0r4p
zE%q}qu<Gw;WH`m>ilhqCsAehTWlh}A$RMV;2BHmQ00grHF$wRP#>BvAfh5JKkHisM
z+=Q-)?GU4E3`o;9Bq?}$^SZ#mz+mo%bVUn9KieTjL&jKS;SeMaJlTC~Wnfr34U$5O
z85jZ}?nF9moY4w&X#Drp5L02&5E|AZ26^ir$c4g4K7qTizl8zm=!4lH9wIv*@nL4L
zn+~ymVg~FyN|bVy`7>iEVy8Z+JOu632XEm=Ru{;`5y`-C9PCb}N)A5cga(@tV4QPz
zIuk=lK}it<QzeHgvJyzLtHzcVYf#f7tPRTW%7>YOg)tPgbsw6KvQhI9>?$<IIfXM|
zSs<Ikzy#^?OGv)R=CH?fOD;CI<l}Hl9v>(SLpVP(hQb!RTU{__WSB4mk|;qD<__(Y
zG0tH;h4b=MJ`OwN^YtOYBETWOLJAzRAafXIfSF9f973RbJQ<-}5e^|x2?fp7qS!7m
zmBDt2sVw>>rm`IHOH3iw%VE28RE`77ou!VbD#1rNbgYIQkD-L;LP^+i7$#K?$=5Tf
zf1#ubhwABBpk^ad*A1l~N39Dbt3bApdZFZckS3JVtl+5}cCrcK3newdiGzWGNu5L5
zeLkfZO2SN|;f0b%XJZ?_f#wpZXFwE=;Tu?U8KeY)L3cy`nvHk(2C-NXwoL@2>G~Yf
zhHqecA=ZLO!KpGiAVV;RZ(xHSAXN}dc=!fhi$gR}cA=!sTv9hhqg*HnYmE?dp(HHs
zKo?3j&n5CgNn}mT^OzVIDY{S+ZW>t^N*03bCvia}tQtmH={&qHlmrjffYTzj3nkS#
z)E_J*dI1}vLWD=veI_>11^DJC5UohKp372CKxG^;onElRK}#($I=v_h*sxggnu%#0
zUWc*3%to9uep#v(q=hnv!4LkNyoihiZ16y0Wo8p!Na+GLACL*eEMS9M%f`&s2hxOl
zX$#8YF?bjv0+F4W?E=UI+>6JESimN<2*1~{AN&ccAwU;OhJZ}K?FQN({CNW80F;IS
zjs<K>7lZaYA&-esa-n1z$h5(^fbAB@X(%CrV*wki1ts`_iS5`DG8VAGlk-`o7?6J4
zshRKswh15uP>Y1&uz;-uRP2)+F7SXoC%*z@0Pb)BcXYtT1FUeyIeCM!oCu*0b|e<4
zQ5>`a-&8xIUV`ZXEhjp#9N*#&n5$40usv9YuPVb@W2^^hK@En{1#IAWXBfN-*sxtF
zslg#^vx*)UO2YHdDsh>&pmdE|Boe+*QfVc|LSW?k$q+dRZqsUU-42i@ocEI<au8e(
z(HBa>b*vWGeMh-1bh%IxR!%T!b4c9)#X6}MO2P~v^%@797fM3142Xp7(qhu&Ff3k8
z##ArN0MgvXRLlXM-Nk*MBwGX0m@p!hMS~m-nqCy(5D!@oI;R3j8Oq6lP=ySL;|>|E
z7~>Mx;X9NKVGm3<Xwio28f@bah*S(yi(~u&QIf-0AVaIx;2nQJxCB{K_*&A&A28i0
zI928i$UB(h4={URz5$&wNY~{fYe1eGOv^{KKxqYcs|CmLmauTd)dJz#i*&duBCuiC
z1cDMN<7p%%T<10-5(9z-Q_tPa$j^8ONeQ<r(q&hO1OQk6Q;;zjNd@<o0ED54b_&d4
z+zF11hmcfo-*7@Ghj|sIn1O+_S(@<~k_w0nO1{K&5|b<k|Idy1@+GFbKw0SSdTjX;
ztD{)?w}70Da@8VYl`h1U4B!=7LL2brOV}U|0|RVq59E^f8%WESu)ZVAVo+X_X#p96
znJ+O<=OjEXh&h%>!LlxwjiinX;#k%NJ0XayWnHi!6Fkdw2$WVx&X@3(1NN&D7*G-^
zD6v2y2bOP`WI06VZNZmF5eXZj6Ox{qHepMom<bw3<pFaw%t(l#+c)7&q=*r3<U~4U
zGiiwwk<?+93r>~M1Q~*vNMZKCRDu#Tp~?d@VN;MuUxM64jmm>si8LLQR;Zpxu`PrX
z=Mc)+if_sa$I?S9kS1C#gsX30hRzfRA<qCuFmbprFtGU{U8jvmHn8Alvf_~Z2XbHx
zk}|FhOAr|op$C@uxU*O}8IL0=Vcdtrsk(y1foajbiX;fyca7!LeG?9$6WhoL-&r6{
zv<%-moZ+j_z#yiH6mXERVzT9seZQTFfzbg;iqRa2Bj$)291IK$+~zED`P)G!Vl820
zU@SnAXG})om{;T>q6Wg^xy{JJx+9N~fpIyq+&m->0|T2Tk|7XhB9q*<EG)M`PBuqU
z#$}FV1jH^BJ!hE=82ylxu)2aduz@~?XVV!$3j#oQ5HO%zOphp)VT}kTCl1Nb9r)J4
z!&EXbz*yMU!6UD>N7NHA9ZcRFlDqNRg6T3WwqPq9LO6t4cao8K!$Fz`Ch@v6Fc2D~
zljRWozMJ$xx>S%Jlr^NtM`0qu7*^>D-eGIqMe-nB2uRE5Al(q#4}<-HY1qgMsEd-h
z4_}Hy^d?|>K*Pe<_u?BCMzqtAQr!1F_);9AQ3ls?S?U-_%V>%l!YK|>f5B1@sK0Uh
z0KOE5sQF-eKq<}>qz7jihp2nt$>$DR=6-xB4ok6kS;_*WWi-VN;S>jpf5h-8sEqSH
zj4#DuFXMI}BDsvaeGp%Y!&=6z0%;jdaYHP{@glANMx;1hXmQ7=&B&F1f{B4q9!VKn
zE7IU6BE`Wvh9Er*$CwxxCnGDXLmB`@)T&Tx7`QE%WL|+%b`O#=1~wOD9!xEq<~C>I
zw>-kcz*vE#j4=n9lYqow;F^ZSLzJ_yo+h^y6FcJ)BqeOOTM;EVqL78Fmt|ziJ<7zu
z_#a6b<0oX!OC*jW%-t~kTwX|{wlGP={4=)!qcCG0k`l&5WKIYYhig63fG)zxu;}DD
z$H>We30cW8WX@hB4t%XSe6sd0Qh*?ghB=p8o{^oAZxcd-n-^*18WF~D^$~oG(nu<}
zYmmHw2x6FW&}k!GNGibMDA%3C{K&unTipmsez>nYM<iERXA@K<-#JcP0SPPj1n;o@
z0i|#v4t{|3AO$Z=od#(krhr7!gSNM8gkF&jTSZIkQ6q5m#2sz}Qw~aQ*Eb^)GdQ`y
zcX(v@GBeCL0ool9iab~r!e|KD#spUg+CFw1qL2x^Sqc9Zw`t!Q8J<9ugD)RM-uDIC
z|MmweS&Ovq3$&R@<RsWJOvvIO!wjL~p#4=LjA;AXqM?!?hoN1cXo%P=1=`hy;-5*l
zwHe{i26EzdxHiO26_EIOEaD)izk!NFoNj>FtpeKa2imOyx_HxSg)t+8!YM@Qau>>E
zoO9(hmi-veZ51EbQFd8;WJlg*@rhmNp&=sXA=@RsvJ04h04D-40ognCjh%mq3<Cr6
z#0~W@0q8D^3H1<d-`NE)cYb_lmq!)^Z>X@n1KUvXo1Nz`(!R0SbfnD<@C_CJ*d=XF
z6S1LULp}QKv!DbR#At|pbMs$z4Vg3e2B4_5q2lyuCI&`QH&ifyoQAR_23Bx0z&BKY
zJq+4C#K2~X6mZ~30~4@AgqavPq^DmXZ$kwlallNY%7zMP(giycLV&h0h@GYOoYZAT
z74Ne|&Pl;%@-8!~Xq=<MoYY>BcLv*>)MZAMT9D^Rnv+7=P$3J6Fa}aLR9rbn#)gWJ
z^8>q~;t<Gwnr^6ox2~=;GBE}t)x(VL$Q(N)4!ltf)61>Yj>xD87ED_3KMQMAJ0k<5
zAF?thWR4{g2g7)H+4DafGDA@gO#%!I*!EK}aA+G`r*J<->P37#aYUOL))E%HEM)@H
zLQF#w=6FG3_fx=IrmvZp{()@4*#d^CM4ENEEOi#7g))c1_ftH+OyPct^h@|R6%alU
zcn-(}QukBb18KrN?M%de3Wdw$90&}H5J4_x<|L2_Bp(P2Phs55%u7Hfki4G)Hbg*$
z1A!&3ps#wxv7h2ANFmh@1l|TRO~DJ1?HGlTIc!KAcwai&hnaza3wf6SqF{mzg$M>Q
ziZdF46hiYPqbd@Ifq@PCI$(H|d|+bJx{4kmIQCP(7leLbViUVY*?x*OAWLzlX2Sa^
z9)Ju$EfSDJ3K|*=h;b1dtM<4iEJcJWf(5_TS%{g5aUPNqloe2jMi^W@0}CgkKhnSk
zqZ<;3?<0~)h_nE2H=SiV0t#1>!v&s4&&mG)8Gt)n5I%%ik0V@gPSwJXYh&P$UUU=R
zpfVzKV0u7fCITQmIHxgSu0ksQ@30x%z*m*QJddR1vebW2^@$n`qx&f!nF2mUHxuj0
z^$<k^av(6a{S=HG!acX?y`RGN7DkbXy&Q!H)+%wCB1}z$_fy;eX`=al3Oi5;Qf3Q%
z_fs%)NNL<5dd~u)pn=bql5{*B^TY|Dp%2i|3<KhfJn*qXu(2bQHKYjp;A=>~vGYH=
zhi?rjqF{rknPrSB$L?V3uOmt{m|7fbND-sbFomEs%fCS(hk7?6@~!Z&J`L(Z=NorP
z>#xJ=ESSZhb)ho3AVV<w>zM07>AcWc_ue2|=)4+~R&ZDII5r@_TWw@6bpFOJ+Wrt<
zB1I%@ShRxDQ}%sqi4-$I<4B}1SHp~iEOcIQpU6Qa*t8eOCAAMoOQeXT4zpZvs*DiG
z5X?jhvj?UUl%VOl(D@R`T_g=Ep|nL2g$BI0M9v|ruzW3emMH*~R;Zsyk=J7(nxn9i
zo9P?7=+DQ*H7j9yK+Vc@kRBqMm9W$(c!#b15pm5*xR%ROVIVD|&B`IRRslK1!6FlB
zb<8(*{_JP?QXHb1MNV-ypAt9u3$s!14%^Qs_);9Aw1R87EOi2;Wi-VN;S`6cP++MC
zRL0$XfiJ~jmW!Y=&Ksl$XBmg6yy3~`4qNtfd?^l5hr_j8ma+nA8BK9RIK{ytlYv17
zn)sN$vGe=C#+Tx-mvMVvkzB^zeTgr{VJ+j<fV7OJI5JWkEI5f>-~v}q+yWPva%>A+
z;LAKf>su;bgO`*LUf;4DqL7&NEui%t`{Bwlmvj^}Ffa&28Z$CHdd<YZ@bxwH*j+hO
z<YRZ!K`T2znLy$VqI`t)+8O7Bz5(q30_g{-VPIfLgwhO_Z@@kR9YqYEyaSyk3>pvs
zAAQQq<-p9q05`t^$$TBCA&hfYqni&8wd+5a80I4EfDiiLl4D|E5U@37WY`HZ@$efY
zZ!x5U%mW$z3?v6)FfcH9Lutl2;cuB37{S`0LU7xXSeO~O-@<(a7kBbwX3&C&BjOIR
z<ObwOCx|pkKp?NGfgU`3haI*WiUC%6G0p*95|Z5V4s>cUgTPutMh4JzAWYNWLj43f
zA(=rHqzL5R6>pgs*1ct7U<D~+u*y<pWH^g-dx#)N4fr_Y&u^iNb>?cotU?;KY5oS8
zVFe`*t4*qm3_|Y^F>eSr#P=N*Lm-F2K4Mf2MOst?kA4)ByHpt&a*#}h4RJHhnS{+`
z?1p%$GBRvLGQ=M4yf@ekfh-d`#K>Vy(0Qinj11iG5gs>&n=JmGiJ<_*1BD)AD1+5g
zHAV(AB&D#LfN@SOs?uc8LL|nJ<U0zC42*#gUJ!(efKZXi8RDShp&61Z<Uuq?a=ZeF
z7GSX2rNYQC2gw##%rVYcfocnbm8S|L!*L{~2nSt8SE{JO$nXiP(tqem3so2yWIrH6
z#2niAVVo2817}jOWHgIZfH{=`dWg0aHbHAfO_1L~0Sm&Alw{3_a+WVd(1uYH6gnVP
zARGoFm~0uf10_H~1wHNCmeCq?ATiTK4v4%RqcJonA$)sA14${6dI?CPNMgjYb}Sj2
zU@kVnaz>6^q%?(Xzo8SO(ASUnmV4pYjC>rViI)2fi*at2)nQ=3<`Zv5q5Yr8@X17w
zrh)NEE_R;;G75EmCc`JuAWZ|~lN{_m31<`v{z8UNR6&{s#wUK*eG<zkB>R;NpS&M9
zpIBn|Njjs*b8>vL6QpTi;=~5KPYM}DHhv=`PMSfQ2F54WNQ<^XE1b`LgSFm3Coh;I
z)=qPOWkfXC9(`tH_=&6%w8$IYrse$(GXv4iHHC|TSEI8q27&L_h-96(rG5$vLR~D1
zIzx~;(4upgI(Ul`<kl)AwI~b8L6Xz)Np8U>c@dxFJA9JdKVTk*1RjcOHBcli5ni@|
zOCUNQARoZH0F0Il3<9;vj0`D1m>3w!e?XhHpoSH=F$})=BOTPd0M+rcK#D*N1_lO1
z4+PZ2W(4bpO2K1mHx}!$^*~_e|3WgK1KMU`oa4p9%z$D(+ZjG+%Li&9gtCE93`{1B
zg4+L>7#Qy%DKl?I+QtP@$jHvj#W)p7SWFIS+ZJR5g7F^{*Sg<K42(KRQeulXKph7<
z><w%fXa|)pNZke`DKRmmO;8XQbIUR^&Hly2z-Wae#i)zSQ9<I^feh!G?2oVxBmlt>
z2Qn~#cS~(YQo^_jnKKuO!xfIS;R#_T%p~w`sVZb8dB~hpBo4f@2VaW8NqD!E6p|8d
z4<v6QnzRtFF)(mP@G*uVso*|}<PAtr!jyt&Q1AXSk_wO*TNhGPz#8Bn2?z%5yGsJa
z*bF3P3|s-oJcvpp614A*u?0y9V+ArN2Z_VLz=fQg5TOm5+X5vmlw^hCU@Spm!6YO6
zhlzm^#ldWZ9h?NxM5Lp+Fq1aO`>>fsP%>vkPU38sNgPGJEF;sjzeFc@_@ZN&eWOXA
zfq{&q54vs#dBzBl_+X_rsEnM;z|6pykF<h{%>aB59Vh}B7!U~%rUx{B&kfRpbNn8W
zF=2^Z@D7{ye<lV-A{I--*MnY``UNVzi5X2r(lfeU5E5??lGxEyh-wA~LE=VJVah?}
zE&6srwtZMPAaz0YfKr?Zs3t#yq>L?d2O@1k6*4d|SVNgY{!E<PnVA_FtB{oOA*XDp
zLI%Vgyh4uLWgsm$6E?y^*nk%(VLxGFW?;mbuo0O7zPR8H8w*Ga&V-G~3$W@{@Uqlp
zMrH;^ViGoNDFo*Bgb}(A78cP1kg&P=Rw2?1EHW7wB%w|ca^z-|K~jNo|5=R%s4U)$
zB#kf%HnRmv<sX@u8CWl`Vq{=Eh@_T*%M0n!G=xrAi44-o7=fe&*>2`C@CHu!u&uuz
z_^L7H;tebe3<8PDj0_Ph%nS^madmK0AJpb&NC!2xK^|)b$$=OQ3=FrS$)9l!sNu~B
z)&`Xl6GO_G5HThVMu9?3W(G!kBq>G}Bo5n5Bqt+$l>pJtAY{a3$HU6Zz_=Vq8M4nn
zJwgVypGX0PFvJMSkVsZ$23E<{j0}wING8Dp<jQH#9d#j~-IHv6NEh2dO+cbRE}9K;
z(GnzOj5Clp3~aGT&Vhy(0|P@5)D(~jhd7uS7)y|pF=iui_)MA*zCaWn9xww^Efm?9
z85o_AR3V26bJ+pVfq2;OCx^}23#D3+dOi74Hf9D^fy0ap+>BTo2T<pM4%fwYjxDSl
zLt5Fsj8Wwl$S1g$cOt?8rX93$ZaX_O18e;zMh3=Wr2PntSx6kd%}5+XB*5G#I90|6
zWC-TUIhZ{#mBg%^LzDzCT@)M<%EQ6Tz)FpkbFkBO$vVdtHd!iomZ=MrSV>+v2Mb5s
zJ2H@qLRh#VRo+HSc7H%Yfmsx?VJ`|{9Z^sQa|D$-5lC4bIfH-;4fv=DDDNk5LJGvP
z58!K6>(Q>RtOu3c$oUD8EES+G2NiW<Jj@KZGZmIZxQtQd7bmt%g~;?!<8fswM9PD=
zf0r?;=yNeMFcOogkTvmeQz26=<YH!E9fX-G5#%{)WGYydK~|=MEgcs;%XFWcnSqhy
zOa+fGTx+I1k;bqPiS!6G6@e1zOg?4?#&9HMY=KBu6F?O*FfjN-nT)E;D)pd*9gnPx
zYd?|+P?Zb}3<gjpNE72lBqeNN2NBLeuq0sW|1ohb<pquHAt~d!g*1kO$UQJU;1lIv
zASvN)KpG`N<RG~EpMs2iNGiDhB8?KkN-L;)K=o&WBO^D`sXN>aNMl}zYzNZ-I#Iq4
zNd;J(i?FX5Q-+m~k;eH!%PKbVfy-5t<rXoB#wTd}+JJ$fMot;jFk|KdjnXoG<YR{1
zG<`-JdF_iTsKE&eRVIFB1`d8^23C-2hDOF|vWyH&B8+T0{D?S*jUF-1kq}^Jumou<
z#F+UOVYI-U4j08HD8{IbIUO#>=m1(m05ThdA=BaFjM|vf;S!9xDAVB*jJ7D#;gXD|
zDAVCmj7HGua9C->09pV5x{2g7V+adlAoFL&Ko-Uz=Ff~lEQ}G%pBW=q7$ccKGe$Bn
z)Lf8ZWMJZBWYiL1W?--tfQBW=_u!^IcohFMBPduvu1*B00x?jA@$&_k86XBgr5K9W
zgN%L4*Z@+$57|_m#DYu)rngGoQj84INg(x1f93P0Gcfpp*<6g^gJPna88aD}{)<6F
z>@*|D3Xp<FAOk@R1_p+m(1L++&Ublc28dlyDaKADbv;Z|1(+FR1(_N0rwK4K<S!Cn
zW;n*U9>m-LR#pv?2kCqy&&+U!5u}KD;)41!j3AXv6CHY)kniq>A1(7ks7H{QffaOl
zH~7+Sc<AH1CEALCAqLCc-ajH=2r*N3wfA%(W(Jb4_BID;qSe*j4MOnjjMAP0FCioL
zYVVsM7ZQE7H{YFo&{P4RU;#y}6o>$c{FT2e%*?>}3P}~$38Z!(qD+8k0oNPXkd$yI
zBXy(@6#-oRPeH~)Bo*B64<KBGSrLG4BKeD?f?E-(io%?G0M#4%NGibo>SF>WW-yb1
zfx!{V=oevT(1j#$hzQ>iBws^>KqPGUHq(DK3lU}p#!JYm*ybbg5dHw^17RixMzJc8
zrftZ|)*^8bvxlHe3Yt9xokqpSf#hX`v9O!cnf}W2iZe4XiXo|DySEOZ5K+B@TmizM
zNty2;m%Kqz#=y1&nFmsbf<coqZlcT#j5m;!F`hx@96;hQaG9;g<_6ekAb5_$1xX28
zMGHbbB5A>fxIt5TRbtExjB}8bG4>;K+K@P~T8aUtpNko(NrLbgERlhy_tcS;FiIhF
zc#$|<UmXz+MX+Edfv5K*keVxuJjfhoBo3@sg}AwH9a4Z`8Vx=SaX*q0?(ImCj)-TN
zQ$W*uN0C%;zeLiD2x6FW&~Wp2Bo*LLVq-#@x<FU~mID<MT#V95;-vPo#H0_Q`;Li=
zQF@6aGXtyrAw~v9BP4l7O(YJX>wB1)G%td318NT~0qH~^Snrzwo-_oRnKYXum>F1`
zH#0IYmLsWU%tPXEb0M9{02`o&g#!bF;3Q>M#ifi4j1ox7xW9q#9e}8UO}9aKAQI<L
z#s#EfJ`f=V(gMPQEKFA0C7999I^$ADax9{(g%w$XEKHoF9(n}Ri*o1@EV(c+z@*7N
z^a!RO-WY%#dNk1i{eU^7MaQ5JVBkB2lqfJmh_jph2PiR-)GcNE>Ve1<U|YZhc-<r@
zsdF>h$4W6XFiIeeNHX#ubC{7hD7APQc<f`M1KMF3VDrHQZ0rz}4bIEpn=wRq7N!R@
zv0@9-L&U@iEb;{Ju*FI<<C!r;galm6Whoty7Gfq=z<$DdkM`)qia6scq#~6YIU!?~
zuT+>ZL}@?3B9nmu-ZcL!?+fY@;A}r&HmpGH2Xk3w21Zib4{ab#l(ipV%^qUg53oWP
z)PC3{M|%4Krhh26AHcm+(6|feFl8dz4{-Gne2hf2A7IL{wjbbQ!JsB>jy$B311=7k
zKQo3P79>8`VP<H7N|z%Ibu92<W|$2TXY@cQU+Kfla26uW1U3y(L9j3)9XpF?Qt$SG
z*^RUZ1T>HWYG;G?fb=sN$}=)B9b}VIKoov)(2|UC&O!w&qa7<5!Cmx&nxHN^R4Kxd
zDL%{$kqTgI!JB~KEB10Bf}rb%;Nb&WvDX6^2MtJo_6@<SMr4<^Firvu8SH?yZ5h0v
zRx{4ARAgqz1M!%4IF*Va>WT?WnG8(3P?r94=kG_zgS0>}tbN3^hmUa~k_yHtNF2Dc
z+}1!g(bRx6w=kB1+_e#wAQ<vNqTsDK0_w~R(7@VgfgD(TOh|<xrhAyS@Elac*1W_l
zDiNnj#2_~>AuS=MEj&yrq_r*)MJ2=t1_n?=QC|sT{2#e>iSPj|4S_U0P$I2$iRn4Q
ztxK4F&>&}EV4$FNDXKh-TbJM=6<p;7IQR&(E}6FQgn<$hNv%sl34N>5Dv+5ZO#-7N
zbg;`An6@hIS0gQ<BhoB#LYGh_BcY#E9ZU&57P%V*YdC;9Pj5iZ1RoTQ(rJQ(Ac%w&
zg5-3XV0uwHO^7gtNt4@Yg6W4B!LUvfs15_U9i>HyuoqUQFl|-BHw6w;#@Q{$3SE2F
z!WaQ6)>pxc^<0oO;9?zAYeS3mRfeP#>uY&ts8gd@U(0h-leE;1y;x_{AS1PJ*BDHx
zoeep)BjOzzR}A2E5Ar2A-NQst(mx_-;3s&JF=znOi<15kod}pTx#=IKA4~dYVGN<D
zSYOMdt3~Pp5kkfKI;BRCnG_f6>y)PHke1L9NdUQ6f3HPGLSLXgm=Ze9V*N14nc(D&
zlB{8Aoq+*Xb`Hm4eI4n=x;>~^UjomXh0uUvoFilp>qRWFNky96<wKsIL8LFJJ_e>`
z{CT>}46L9z8kD&iSfv6}2)-qr6*4yy<A5|m4N0j?%lN06Ff*`L9bjZ&%texBOhD#@
zBXQXBkOr<1<rpl&xfPjsd-a$ZSX<XKGBDO4spVdUG;0743V2H4{v*PAu!WI<aR-tz
zZd0V`0NA<_gx|PRTv&bl85tOzk(6=EAr1V)oQ2Q>YO9+%F)}dfASnY$vwcIFR6zte
zZ0wI)iHYU75i<j;0mx&@NFHMpL+0=zao}?!FhjV`HX}?%#1%}MdoC*rD?2C<ej%x2
ze2dI^g2cfvUzZ0d@YwG8AuL05T43WW+`Cw%{S25H7{4MZV|;_efg2Cg!gT>@LI#q8
zKp_W{=GI_TWPFaKgz**<hpWX7;T%N5fobO1!l=Nw97ze|Y-G+PBo4en0(JXY7(*Gs
z%N7{8dXU@>au)={k{b73Rz=1eNJ<z_BXjm4b2cJzxSEkXf$#y$SYAa&RmSbeN>(Ft
z<|A?7;R(~Ldl*TU+ZoA=h_nGy%iG4!SdOHEF&mi^kHq1YwM94+5$|w=Ql%M#kyJ3c
zA#*H|I9zHr2!jyO4Ks-EI3ovR8j=#mNMw!=5{K)fCBh^`+`~;;#;D6^XoXP1sDjK9
zN8(_Hp&gPeSH1<p5SZx<3@{d76QdmC93&--{m7gqBo3xME0JU&DGNrTOu)hf85qQ%
zOi+=?h;srKs)zw`_A6)rmDyx?4WPoaENFiv3u7pAIW$tZuusIo%57pNV&UqE8%TvI
z$2yS8w;pNy4UwGSi)5FFD%&tKFdjozwHJv4PdYFix|fk;xpI-J8ALXRspXDjVq%@R
zj*)?}1xX!aH4+EI{QPO_7#Y|)ktzm6u7@Qr?tV7T*QU%2jMI^np;WJk3=Y@x&4dwD
zy~6mcplTMSdPQVqm>SMDB}P#73gfdvt64S=Bzv*c<o#@%zs#5!SmT=+85qNm)N&!W
zH(>DwGo68fdorUCfwl(b3^L)i2CP;>vWQ??1GX?0p$BJMgMkluJpsJC57)`r&F*K;
z%)kno6F^x@03V1(QYyy^SxdmCf)s498D9nlSX$toz{Zqj!OXyDjiijx2#Le@!xxd<
zVTU^*8BoCc+?<(#Q5>mqWaLKTz!N6S%6w(8EQ+}Z8(?1GF67k!xeKSc4BW^LgBcFf
z&cMK3#EaWe3=AmYf=IFO^)VCKn2uNy9WJoCgn<DT-`oYf>>&L(-472Jm=0Y?xWIgX
zBYa>PlDm*MojCJhI?&8V2|h&l!&Ku9KDgUqs?p45;KIIW3YLLD<qoMUrZlba&UnIH
z0t-F{2GEMB0+1%;8BbQwiYZ3iE2R(-33n^#+E|<wHKNdhtCwYD>ak{KU<Iv|B4ULU
zOdk<5oUEV~QWUL>Vg;>?qI^XZERcz<h~esqtB7IBu~x(&NgQ+PuyT-T8UIQ<d~5O$
zu?#W|gh6xa-JlAb)H(HAAWg_AjPx~muoOVfoVpmupP-Zm@&pJ|H^ni6QXI%w5T+>Q
zF@jPa$P^I9odQX15`s(v;ekkrDAhHh3IRC>gqfD{|Fy$bU1O#`&}cuTx`z87b;4N(
zG*pxbZxX=Tg^Y6^IWjX48Usz{YPF}vV1F{#L`TxbKoNlgE1p5qv7hb97z176Fqp<b
zQ3f~>?R8lDiktyXm|m1|dqlGaCQa_RJxo75fg$Ft2#wq0n9%~IaS&!o=E66l1yTaS
zpfnDh(XwhVW@KPQ-a`da0G`nTT~`l2^%8VEEMq7`O}sQC1L(?cc_(HDCL<?i$Of7a
z1(XdmAYC9MoSm2%K>Ng4L8=)9n3WkB!a@2HVfsKDZx~cTN<hksoR}FZoR}F{L5dhe
zIJgxV83aKBHMNS242=JnxIhOdF|B~<u7feaTTN79hb`@NVrBqs8e;{iW~iA3)eG7r
z#&jE|1*Dfj6{HMg^BX5-hEE`yL5dgzeycJvFgP<aFmpLWJs4!l$iN`ruf@n90TS1P
zi8pI8GBhz}GBECC;?x731Szmglaav&qz1Iv4O~Ki)F@>#Fm7N{&=Ut4<DtpO0NUfm
zlnFB?U6YZ4K^3F}<eDmHW`+i5P(KT_5l+BGnvtQ;nVErU22439xEWMIN<hk2Ix{n@
z2Pp?BVz62#$;faHq!A>Ca?b5KH|Uz3Dv)oW(gaE?#@`CYE)<nk5PKMZD|on(R$5^;
zf<dL#LKiYht033GR9fMju_*;PbGXjf5LiXR_*-EPD1nf)iUfI8F?azTgH@X(Bg0uY
zL_rO!^BCvcbYq5`;0sFrpc8zPBpDfgASvyGBvl5+IiRJ_;JthxrBG1@zBx#XtYLzP
zBRLqqs71RoGcfK!QpLLd5F=vE9b|J?2-C!P(3ydT3=A>Io5LU`GJa8O^<ZXT1Z@q2
zh%hiPHX<2`l6YXNR#{A$bT+v&Gq8da58Gv=6A563FhELb1_lNeBPON-4`zmmOs_UE
zGB7eeL{iOH--gI`2o}r`wt1Y2AlLOGsbb*EMq1~M2zXetiftZe5=c)Yk}AehBo5+C
z#s{a7?-7FpS14#pCu&GR+{O4sZ5PN~oFT;kUtoC71H9@Gw7?Kv-y%#$uWuQRKqrYy
zGBSYHuQRE7LaTseQ$_|&P(U!gQvt0dgs|U>&65C?-Jlc$k~H&VW^nUlW?%(rW(6&W
zX9X{i7dX+%z!2ie%)kr^EpWXsuZfXCDLy`#fg^)iXxkeG1_tSh^9&5kpkqOF;^Pw;
z*jGwzY+_*0iH}cWU|*>NVlzlj2PxU;$qW)sWMFTUj)5y_)B~{@q_=^TT!Aa8MN(1=
zQ8EeKMv__q?xBHph%*22WM*L6pbECFfI(`79!Qiy`h*Gt1GAnNGvwq&))+={;qTC6
z7+GT&^?1KCfV_~$z#7A74bsgZy%?k;0j?tiSw{%6ju4oRI*^V@Ud$kqiWykl7-bR0
zx-n{kj8y^!2df*SJ^Oc1Fcn{9U|<HV@6d^lFJ@p}E3N$<?C?AW*0nky_2A%RUF)R!
zoq-{`nK3>-lYw=;1W1N~K{^>^-wU{XHjMHh`xvCJf`X01o0$Q8oCPRCAjUse2OY)E
zARP&^RmU3~@&yd6i)2BzLJeOc3^rW)`vnFDW`A#HNJ?Q%kp{T{oKjd*j6iG#X*-bh
zjoz>z)niluSr6Vj&Z@^~4&o@q$LBGy>M^=N3^fH=ydQ4pR5_5v5JRV$g4jA>^;6wJ
z%3<D}4)d-UNcSVS?hGU+Wk8+u736c!HL%D&Ph?>Ip$+mm#PlELAk(4V{ly33Fi2lg
zW?*1;@PYY7j!}{ko;>6j4ZyJ_$+1qBfgv80IY1b8>^_53BO4aM3U-8o8iWG4O7a+R
zGvi+IIDlLM!f}_F5u9i?W)6g^&%AJU^c_}&j(bQt{EV4+;WE*p%zOyWLuOWl{>upc
z(M+uT2#Gd?MBF)M9)v`x;AAG*dD2OV#hJ<R#U(|VdFfVG$UFvwRXnWx2u>;smJowW
z`^hpP+!&O^h~)XFOh~3IU=o1qiC&Gwi93nxeQ6}qqPrOpo{83FLgGX+vLQ^H!HVF-
zeP%+qAnqL#4+A4BgP|~!_;x381_mZp22WuI24)atBFVtO($&Psz$7uzNrHia6{L=V
zflZdtP&kNjhZCzHqY!%pcO+{#H={5E1G@=B9-q4~0|SR1qrD_EpB1+?t0i|HpQo@9
zw~b_qFh~t2F9S@%Q`lb8MpA}5M^b^Cfq@H)p$rV%=%U==+zbpn`V7o`AXoCTf*Bxp
z@?lX4vXGyH!HV0O+mc&Cn1Mk+kI`K?MOXpsTtPLkPlY<07#Rf_4TTvPg!LJiIY8!$
z@H238gBYS>5a)7Rg1KUFOG3pF{uW2|F2b`CAm>3s0c4n@0Mt||JqFb9v5{n8kOsL8
z;xZYyf!yffCkqWfu!AhP85rbX&Ifr`9<C7@@HUblVFeQgW)7G;pz*B8%?OG;1_mWo
zBuNGaWfO>xSwTLAs#WQ1Vq|~>k*Xe}p>Q4_Br?@B7?}BFxEUDKp{@dJ0=Y^9?hvpK
z5J92|4HB^X85p!s)p-g-9IOo&2Ac>G)PXt_s#Vtnk!bax(F9g)#Ld8<FU-iy$IT6i
zc~B4-KvjS>gH#y8Rj^uulY<dd1=tJ*24hJ0fb^O`-3*q228k)$g<ucDlD8Q+W}#sX
zO8KCeHOELb3=9^?`eEL-1X<)MY$6G@#0r!oQiMVA<RCHK2^^Q!aE;(7hFNR_PUftT
zWNr(M4zOoInT&zKj+-%5oPog}T{p;o4j@O{NapduawY?VBU~NWdmslwqTC6R_2eWO
z7@VD;$=QX8fte5FQCE;9AQRo%n;03H`9Mr}eQ+-G0NDXHA8sH6gC`@SC%9DbQe^NH
z*5_tm@CGS^JB8bln}NYcg@K#fj+>c}fx#D=Hj(`02NeRx4FiKe*xg9sk4Sj|kc`5>
z5Xgj<HiBdrJcU82HW=A3CJ6?H5U_FZf(&F>GPEEIg{lR+1(XNEK#>Q}WD*Pv;mEPT
zzz_j93mgKFG#!bo1{71U;xNhpT(W@-j^<`$V2D9YL)?%OHx?ucN*;*9C=PB7IDH^u
zE*=rI3=9ciRiJPJI|jLgPK1OLDDIMw{m8(O45|}A!IA<BL5K%ZK}>K)gJz>Nu*vWs
z^Az^s_LY!DssYkrB?!pf@MN6<i33p1%tSQ-U4IrtI*-pp5|sEE7_z|vAiuzU403!9
z!ttPt2nt*VhFoZPgOiH|H^{m?XuN?V5}NVyL1haALjgz%oF63^7z$Y!nfdIvLG=Qn
zSSbQEAB#cR6e0$zTS}m171$oAp{1zq1SKX&o+<+uqr40Z<;boBIar1lQaM&Y{Q@=)
zB*DN?2{sKH&XBmM;$}1i7ZwZ*)gWf5I4B%ypsr)J<c7Jf)(TW7LJNyJNUaS@Y4yU;
zjNHHob`mQCLn9-yc9bY<VnnW17#Nyid~irIFtot5a$9nvXl!L<VMGteHb!wqa5CbC
zl*a9h$o|XY^WjELLmiCJkOEr;3J^#*but=&YjBWfx)3IS(>Nr&85p`@df|a7!wS*e
z1CxQ83eo|Q>BVAJHzPMB`ufl$A(;s--46*%HU@?XF!SLyLrk9t6X%8$Lz5VV;bD;n
zE<`6Yib6}uDU8VVmJzt-nhMhoHrIj`l&YsOf-@_mO*b7DGhhXv96SRg0!=)g!l2-q
z$;b;W1!pl@!kYjL46~7Vos5zU4090Ph37X0hPe<?P%Z?AHmKYIrM`KLpkfDB@PkAd
z80LfA3snj6@dAi$sDtwOAQ^ihnkXb-L8dN(IUgERATKRugeGKO28JatHY)?eQpS!Z
zMn*{XWMEhZ<3Wq7<w$%6h82ulaIXt8GBB)Ugyv(gJ<xo-iqVo0>>*Z5?oLK<rMw#9
zQn2rBBw^LW8b(l_f~9N*hP7B!f|CjZ!#Y?<gR8yuFk7G*Vgn;M(?T1v8$m$`4K7GK
znt@>xn$f6PW;3H6#MNN0Knjd4j3x}A_WD*tB!N>1s4m}zln6mVz8xupLK5W;sC}T4
z7?f2YxnU<%6cXT|k{7)I-^D1(2r_XuBe?Ehh18j{;D*2+MwC*P)sh>M#P_23*MgOS
zVIR~UnC)GR(299KNGT|FfxQB%)(^l^13Lr5L2xjbNTL)-hrlHjiqK({6b4FPN5G08
z-a>1W9R*8){B(>FRPZt|90ywi@tG&MOm>i%25G>Zz#;{0+nq#`LUGM0Mo>i$?s9=U
z9^hWkX-3qV6l(q%Mo{Gia`9P4K}J<RVQywVX}(Z#K}G@bnV=rtIZ(<11rWIKI1dUg
zP)Y))3wudWOfoQBfP^ks6{rgW5{1O?MTiVkM;;$Y2A0?_LFFLDwF%fPh_1`XMLsm^
zT|o+BP&xq><1$>3BJnEJBuH?BWRdN;hE+C2n1SIsnoK*RBqXWdU}Rxn=F62tu6Gz1
zZlWm%CHz|mF>v_?%FECkdK>0qummLE!CZU?lzXA!1uiG=LXtPA4+2ld_rMtq+`fe>
zWnj1uG8D=Kc@z{33=9uIqR>Ewl$sBbgAiOqJOV`|NDVYVAA?N?_w>M}5JcY-MrZ??
zgMr~GqV@ns{xe2UN0))&IY^uXR!V^q@(V_522hjxC8HVx1H&suQ3eKv*N~6_xfPtZ
zAR+q(A_{c}Jiy;FLi<x-r@mtZEtPr?E^k0d^8+GqxGlLMdH*A7-sgtp{Z9xBz}`YH
zPd=lhU`V6x3setkN@QU83bKO(o(SL(^9>SoP)~rO0hHbt7`{Wzf#hUJY6k_+59G*z
zoAMK?8dN5MsxXksU!b7n<A#=Ukkafo*u|i#50pn382*6ykhBg;RUo@Tb@E?q;#>?2
z|3IM!i7sf={|BjrM+_tk8kkU<P>|{qluH_!&`Vj6OPes%LqZznlV&DRVu1|2v@n5M
zq#(C~THy=~txV9$myLm;jR`Vj#K6!FWleOFm;@R>>R>`t#UL9y!KOgM)>Ak~l7XR%
z3Dn$#6|c||t((aN+=uL80u`<xjlE2u@(@%+MsP<$`$BzSS&$e=ML*aeNRXl#HvwcT
zD6GIG9<)-Q$OIbO0tNacL@<Dpn<sR*Xfl%-11RZ&MldljBSR><7z@K^#?blbqS*M1
z3?b;kAk85}X=Y%+VmBj0Fg6p3bq<DKu$YH#K8TOSB_NMru@*9u1kwY=Yz&{EEHsLE
zm1r7KxmcXW2)VivSsgW1;qW=Kbr@_cDS?q823;97Re@YdY(fJiwLo;ofD8!4NU4kr
zL@Go#4#cNGGuEI1nTd*twgDscF<`L))oc(COVR=fqhsu0hg}q1FNlvdZD1r9kV<rn
zHKAi<d+=l>npP}D0Tv<bIx(Dv#RJ%NVmJ+p2hbb}T1JIg3}RD+;Vf*5FkFC55%o-h
zFR;M01|~vOB4cErmPw%8k6{)Q!^8-fdvMcOT#7AYVVI6h5%@Y`6ss^&3>NE9G=Moo
z1q@gvI3Zy~KPZ=CR%}?3CD96DmSNIZ${diXnB_Jl3NfvPh>%cLl3nIw2{wr3$Rx<i
z*g_mx4T#OeV1T7Q0?8m_ELLJBH|$m-8-vQmYA8lijG3Xn0K<jYt-?~YqS}be!xH;g
zvI23cK+eHTU&yv0v$3QRW`>C?K$mJDD`Oy59f~G24kJSlng|0ELpiz-1Ch#@873~k
za3(hMFf2e4U}V531Q{7(kraTL#Hj)Wd;~`7z+xQOOf&*ZeTqd0O%oayOToy<06TvU
zu9i4eObqqlMa*z*44@5jpBXVqQ!F+h>w&Pb<SvK=Dv3oImTZKX*|F$jLaeHT+JQw8
zh8k==GN^VW3X7YNWZ_J#IT*7NgsVp|ux50Oo+d&)DvP)XCQcQq$sisUUx9>CF%}P?
zDuD3FcLPy@L9X$j_7avd07D4k2~-kW0fbEqRTqqhC5^H%)G?GXC}AmAFtQ@d6a-CF
z;X|zRNN^m&1uzzImSC}h0VBH;o&7M{^hB1ZSW+(*A(+olX)HdVFa|MvfodU$N2KdW
za2v=}R7{i|SZqKw1;oP=e;6GB1}uuOmDU(7G>`?Tn2DhnwsQzo0)>agK8%FNz{XH4
zz^2TIB`>0wg}vK>X&e?iF#`gZotP@I1U@!JL<AX;bvjWdVRQ}Ag9=pI5@8auHY`5H
zQY}$a6{u~8*@HoL6DAu=j=@p@QBxJjl@vAoK?aNt38F<MmZXKI0?fr8cGyM18qf%=
zX@iKuAC!MEngUqTK4w_}(utAth$@soIx(Dv#RJ&wB*wL9fdej5G2Dtx5r(s{DZ+38
zHbvAkiKsG=h@JtK1}!#+6JZi40x?`QLWTrEe#b}vSTZ>%>tdGqSaKE?y;xLX#uP{d
zYw?ez&yFDk(u^Hr8LDAKY$k!}0r`%oq8^K0m>I}4mU07&5V8&!8%rkzix5mTDvc#a
zVC!jM6GJr!!DD48U@(!!XydViM#b1jk-%XP!X^X@OVP;;nuJEEAjHCA0=CgqHijC8
zdaS)k_%0!sO{^dXC}W;X1(Qdjx!{K}F<^unJ~<>KP?*dN6E|QC?O_#UVt}1FiZB4H
zLWDGeg(Z_>5kja(XJJX-ScEtkChn+bD`a59)`!Qa((tOrbO1&<hOPv{X8{E$M$}*z
z#Zr7g3_&GXK;FV;<c@j_QB<8E9=34CXe?k+#7K-H3^fcm*C>G8f`+j~Ar>JtO-Nj9
zuBPI81tgo`Of2rhA_P~C#-Of)(F_M&dxd3I2V2>M*+B-?)EGGgi_fs>1i6EnJ_DJD
ziixTiIT&id6$fVKM>Pz@!_tnxOv+en#Z-jbR!p^6Yy~+66%(n5s3tQJO&KipKNIZy
z9k|1=j8ZTYqlg7@;u+K|EY`6RqX<I{1D0^YrU)aPFwb(tQlZ06*@C(noV5%w3R_H7
zSd4<5*oQC*iz0+1j75|pP_D&jO<<YSgBgmTv9#tevo;ntU@9Wk4VXHyxB)ZIFfm|;
zJEkfuF2z(ttV=O<VsR-VC}AvChI(wRS(r3}#*%Uok}wvQ!UraWpowd2W68aY7$dyc
zjKZAR!={QEc9sU*U05t+B}Ng38f=*yn<9)nfZ3MD5}ueP0k*`3sS1lx*h&HnN5R7f
z&cI?4Tn^5_7UpnCI0H)(#g^kR9EGU}n|+w7u-J#0Z?J_YrYbC<fT;+Zt1wkzaTPp-
z;0#uVI^r@aCqtP4TP=eOmaZt=FgOEC%?6i)Gl<Iibg>pQM)6pSsThlIu_+>Id<-5s
z*wzGKX@fE|)Dpim2&3DE#Xu~LSA?4|Sy%^>FxnZQQ6J110^;;yQHALYP<4h8zC<N3
zkWP$cXhe2KvE(o;#XY8Lu?9Q3GAxR)<#CLT3c5KA45L$#$YFvdT#=<AY;vO!q8pjS
zl17lFA#5VuMC9@lEZH1G2wPIZP=u{tgP{nc?}M%6f_M{|#L`MdmWHs23KvigCO_|E
zgelSG4Ms>1Rdf<nC=ulbBCW&lAS7s!Ng_?c2xMe45Ns@wMnWxxEn#9<j7<?{L5QIW
zi^~wshOvk&`w_~qqyr4MU<qMRorrCo2a8^eDKnVmglH`32xKi$Rq@bOh&xoU#4VP_
z8_4I_=BO}M;$c^a-Fhq|5m?&#AQOWy##XSKh)WdfvSExS85UI_%dxE_#<EtK7~`;%
z@K`LRu`29-!WDD~aV#l?iJ=&yD@~*_Y+8vGBhm_l(~((NY8xy<*qnlF3N|*D5{(%&
zH-oNrpwywe1H{MDs>31#Qi&a7@e7vN!BV1N)re7?V7C+`id8?BUJHhiST$m(0$G8I
zu@p_H3P3!p@ePu|#8}-yj0dn8g)we}sfb9YQQw;wegaK>*D}apl<8O!4yHFiB3SBh
z4p2s8tHC;<PDFDLVk$<n1!8I~R#Pz)gUmq3SiFSG_vl(de3Cp0(twV!Br@E7Le~uH
zMGz5oSnR+w31k*VA|)!VfplVN0AdPZY1?A760yx%V>k=jLU*DRVOWPf95ANch%Rw)
zrU&dvl!(X!xe!YPLJ|q~>_kMuC(=VCc?aZDbWD=V(KUk-77-zY#STo9Kq6$f<UpEH
zF;N+V$O0YYO=6m>s4f8UsObvonuXEU200fM4{-}I%Ntbhfj0q8+<~z+3qutHmfi%W
zB9I7{+{npL&rrjlguSvRBJU8HM2U1FX$}N=2^ACV8fy9sqp(MH6O4z&Z;�v}A_`
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�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�AYk<{-{xg3W9>nnT>f2A!e;pD)M2z>o_S
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	{e24ozGUdfrPqnm8=~mZ6Em@^34eI4u88
zK@*4N-^FO+u>89TO&peg52A^~^6v#SaajJnk0uVwzwgk*VfptPnz%9-r2Y0EO&peg
z*`e)gSp4Qf@3Rm<6Nlwr2{iFL&5(FeL=%VQUrjXe&NzsBjL^hk`PUIm9F~6r(8OW+
zHy%wKmVfim#9{fj7EK(Mf2W~|Z-%b_T!JPJ%fGwP#MwZXCo?cGoIw-sfu3)66-^wL
zfA6A+t3ogPdWI$r%fDaI#9{fD1-i~17LTy}D~u)%%fCu!;;{T{h$arpzYb{Pu>9+f
zCJxKL;b`L0(DP3d(8OW+Hv>)F5qfb{A(}WW|2CkB!}4!Gnm8=~&O;N2<=?ev;;{U?
z2TdH7e@~-{!}2feer;Iz!}9M-H1)9j`vXlJmVX(b7bd~Xse+!*#)&2l%fEtX;>W8Y
z^@tRjI4u7vp^3NGLey)ciNo@*F`Br`2}u66K@*4NUvD&VSpJPd6NlyBOf+#={;fb0
zhvnaPG;vt|U4SOu2|agx9hx{S{~kpXKL=eG3cF_<7XCia3r_E&sfXp?=V;;#(DTDT
zpozos?|(FLSpMaM-lqYx7nXlz(Zpf-R|icTmVd3$#9{f@3r!rBe<RVvVfi-^O*{{J
zK6VzGI4u7bp@}bpp4(fECJxKLU1;L4{5um(9F~7qpozos?{+kCSpGeRCJxKLuzO2j
z;S9^aPterE^6zIfaajIkg6<oDnFGteuzQ?f;#$ys>%wU2Vfj}YO<cAPlD|~Y#9{eY
z2Ti;HbV)L3-x-=XEdSb~i62OY<aakTaajHhMH7eR-xM@)SpF?W6NlyBCNyza{+);>
z4$Hr*(8RUNAmOkBO&peg&!dS8K`#+~fF|As9Y=kMCJxKLuzT%c@zn~wkLDMedRYGD
zgzoo(sfXoX2{dt7{#8d4hvi>0G;vt|bwv}0<=+rAaajIMMiYnS-)uDTO-~`=S%M}G
z%fB^f;(wv%X|$q=!}9MGG;vt|U5q9U%fFk@#9{gOAeuNV|6V{7hvnb<XyUN^`wmSU
zmVf`EiNo?Q4|H7yEFNL`R|HM`IrLm&Su}B2{#8X2Uj#kxMGs9JmVeFA#NT{@<VV;#
z5tw^m`PUsyeGxY#9s|(CVfi;6O&peg^U%a$`L`BL9F~83(8OW+cQ%?hEdOpn6Q6qu
z;?6^8;;{UC6HUAxdY<7cH1S2y^`f8A#9{gOH=1}qbUz~t^gbV0c*63pFq$|l|0<!0
z!}6~onm8=~I-rTe@~=OdI4u9hp^3xtZ!VfREdQ3GiOUv4(n%efI4u9Rp^4i)hJ=4V
znm8=~&O;N2<=?ev;;{U?2TdH7e@~-{!}9MfG;vt|eTgOx%fCO+#9{fD-5=s_SUke=
zuNay*EdR=(iMu_4go8SoI4u9_qlxP*gxF_+CJxKL4rt<W(0LP2G;vt|4MY>K16?xD
zz`ziNCJxKLnP}p${9A!04$HsoXyUN^I}J@7mVcL`iNo^mJ~VOYbwCVf(8OW+_c59{
ztpD}}O*{>H$@X6~aajIkh294Oi{D$&eO`QM;;{THizW`szdC5*u>5O{CJxKLUTEU5
z{2PfT4$Hq8XyUN^TaG3U%fIz#;)TJGagq)+aajJHfF^DZJ=b(5nm8=~u0#`u<=-7>
z;;{UC98DaSe_{8rz``Gvf1jeMhvnZdXyUN^%Nz*FH!yQx`Bw-{9F~6-(Zpf-R})R#
z1X|x2p^3xtuN9j3<HrzpIHQTf@~=0VxD|B0P6(PfEdR!!iB~}HcS}VRhvnZAG;vt|
zZAKG^<=;tY;;{U?5KSDGe>b3s!}9M*H1RAM$U3O&XyUN^`wmT<%Lt<WKbrVP=zXai
z(DU_S@e9kp0%+n=(0i68(Zpf-R|8EPmVeFB#9{f@4NV-De?!s4Vfi-&O&pegi_yek
z`L_v89F~8((8PtI_hU{*6NlyB*=XY8(2H}Ipozos?-n$1SpGeVCJxKL*U-da`S%%`
zI4u8uMH7eRUzT7<{(!|JEdL6liNo@*5}G(H{~Dr+!}6~sns`3+{&6QXaajKKLK8m-
zz1JWZO&pegqtV1KLoZTJK@*4N-yAgY!_af?O3}n&`L_j49F~74qlv@v?;<pDSpMCJ
zCJxKL2hhY}`S&K8cpvoqy60%(u>AWEO?(UV+*f|+xvjAH_51;;cO=lnVfhz!&MQp)
zpB0eyk|vsZSpKy@6NlwrcQkQW{tZJDhvnZ?G;vt|EkP59<=<vBaajJHgeDHlzq8Q9
zpLIgg{bDq6SpHp&CN9YZ3AZh1;;{UC6ipnKf3Km5!}9NQG;vt|{f;IM%fD=)5ck63
z1(ttB(Zpf-R|QQRmVb@W#9{f@2~8Z9f4$JeeW2$u1*3_>@^3VnI1BW?zZ5iaSpLmH
z6JHFy$GH?u9F~7;(ZrM9K+<O$nm8=~PDK-k<=-V};;{U?8BH9Pe-ELF!}9M%G;vt|
zeT61|33~qacQo-mm!a_ry~h9+zrwtb^d^BOezyYRUwJg~qtJV2Owhz(>aEel-J$bJ
zp=jbT^)YDT=QAMgDMb^9sjop3FN59}IU7wJcHYz?G;x16NPFV|nmFu!?Xzg&u=`=J
zpo#ZbL&E1Xnz+ORNH}wcLugny!|p{DLKENI0x?GmO&oSFsv(-V1#~>z6HOd;KWrG9
zIP8AdSTylw=y~#`XyO9UbC+t+#E(PIXP$y44!e(aHk!D@1&F^kqlv@rW8H-&ejO4m
z442TvVfV4#L=%4iJ;&oCnmFuS!5?Vi)?ScwB@lrcFR=Sq#nHsIq4x;rqlv@r8#O}{
z&)f&`uOFH?>^{&?G;x0DdgBT-@vG4DB&VW@!|w5%gC_oIH^e_%(8OW)c<x3Me+NB>
z>N1)*?7pX4XyVDxbN)Y}iT{D_|N4n0eg}F^mrx|cU9j{Ioz`ZML=)c$Jx|pLO&oTf
zn<bj~+9XIk2BC?=&TouF6Ssxl3($Zj4!i%Q9Zh@@v|e0^CJsB_as!&UG4wvZvuNTl
z^;glvTcPKV{Xr9lsb_(%OM->lR_OgKrfA|Y^|ol@0mhK<i9!>HsZT-^KL|bNuoF!j
zrhX!txc6^}`FqjCVdrxmMH7b}!^`j-O&q5FJ({>Y^!!i3Xw>urQ!j}oZoU<g?;Oy?
zVd_25#MPktS+dZ?VfSYhp@~0*-bXV9O&q3v4w`r%^xpP;XyP#S$I!%=K+lPNizW_J
z{}oL<s|n&?ap-;Kuyg{uKT94>yaIafwj-K2OuZ+X_)X~fZ`o+#F!jY~;;Xhp+%pSJ
z9HxE|ns_O6pV|>LaoGJ?uzT8J{#p#Z|Lz?Q_21CMH_AiYBLO{U4rUI_d<8Ud-W!ng
z?2aZ5Q}2%^?$8P`zYt9vc7IkSnmBVN#QfQ4;xP4#(ZnU7=hz%Y6NjlkizeO#b<Y<x
zahUo)XyQNjLfkJ0y-yw%KCt_<)X>C@0wC%=(8OWt1JJ~eLi>kBXyP#SRcPX;%OLrD
zA(}W${Yo_P_j4iYPos(Ngx)uC8BIJ5ntr~biHA2p%=wEZu73sMUwP;`udwhr3%x%`
z9Zh_N7DT;0n)t8V5c7S}#5Y6l?}$bdhn<(3f+h~TU#1vMTng&n3N&$}5{P?R(Zpfx
z{~2iFu=f8lG;vsado7xHIrO~rLuleK^(WE9r>=mc|Ho+JF!is{#6`|S)H5eQ!Veby
zF!fw$;#;8i`Dvnw!`lA_XyW<Md)WQZ#9{6KXf$zH`#%XyT-FE@&W&i|8D0?anP}p$
z_WuGj@jmFiQ9IDYVeS9@XyV(U^W)di#9{6KCuriZ_Wx@%amK?CcQPlUhBK`F&xIy_
z7kW>P5}G)y{jZ58{t9~Wh9jCdto`qSChn*S=>R04iNo6e>1g6I(0h36(Zpfx|28yn
z4d{Jd^U%a$?f<1{;u`}X>2NQaIIR7D1Wmkf6C^zEpozoU|Bunce?apoTM}ycH$&$+
zl+nat?SCyaafQ_o{Z44&u=c+vnz$i!y-FgQIIR7jfhIo71`-YpXyUN;e><9Z%{_>F
z7NCj4+W*VZ#M|Q`;dTH`9M=9njwa3uz3=7$nmDZe{~S$x$$yA@_@L{LVC4y{{V$3p
zz8X3XX^tiiYY*F@iFZQx8AYRs!_+6EiEq(|r1LH`ahUo^XyR|yL&E1UnmA1TX*6+F
zDE|eNhWQt!{sWr067+m&@f1inp{tii6L*2GBlJcShqbqZ(Zm@8A?`0l6Njm<MH81i
z15rO8O&q3vIhy#ER7m<fhb9hFe+^B%8#+Go15F&(-eyQe4Tl|35cepdiNn-up^10B
zgsAsH6Njk}K@;bOj;mCoiNn-4qlt69g1B!fnmDYzy%tUUxHKfaoktUgslSdU?))C&
z{-0>#F!hXS5c^^2#OM-)uYo2GQ*VGKt_(dVDhN#+*4~an6JH6vZ>R=M9HzbnO?+7n
z#68Q<#9`{!p^4XXLc-@NnmA1TT{Q6>&migTKbknKz0IBuu^$#bA%c+b)I<}9sW(Iu
zzXHA2DHu&0ral@?d>{0FgeEj`nEEa>@xx0X?puQ<4r_03K@<0Z)?3%m#9`|1p^2+O
z%X0?k{d=%*fT`y|6Hl85agRQlI841cnz$ge{ES2shqeC`(Ztt4&pl{H6Nk0`yV1l`
zSs?CNizW_h|8GSTUkW|%;w+jtto?r*O&r$#e~BgzYyW>j6Nk0`8KLJxz{0Z?dM*|l
znz$HrU7s+TIIR7zh9(Yc|C^wR!`j={XyUt|<A(ug;xP5$XyX2xAo-;bO&q4a0!>_W
z10?(>qKU)Q&p;DDX#p{RJDNDG{l5=Q{2a9Xa|cZv*8YEqCJt-=e?Swz2_0wS&w{uY
z7B35-_mZoliNo6edT8Py(Eg(vnmDZe?~5kR3O!dU6-^x0{x3okhqeDJ(Zn@wLCU3x
zXyUN;{|q$oIkO?^H=v2b+W*_p#Ot8_)AMNJu=f8oH1YLcA>sHAO&r$#|B5Eg23_yU
z3thJb3x8PqUj$A3z$b|Nb<o6N?SEr5@k`KkQ{HIeu=altn)pBH{R>%W;;{CAA)2`B
z5lFh7f+j8i-DkQHO&r$#-+?B+0J?AP0-89i{eK-z{O>7<z3<V)VeS8KXyQ%KduI8d
z^(ri!VeNlWH1R@KNIdGHiNo6erfA}B(0xFDXyUN;e<+&xHt0H`JT!4w`@a-TJP3O4
z*c>!*So?o5n)p-b{K8Q*aajBL44U|EPDr|Xi6#zH{}D}`Aq5it61k9Yf`uncy#kuJ
zhC4)kAeuN#eI%MV7xX^XGBk0R`Z_dm326IpDVjJ;{aQ5f`?nzOxrrtYYi~b96E}k1
zr_7v(>R*_8ZZz?m&~q4c(ZpfuP0_^D)FAD*7&LL1`V=(r{D~0vx1ou{+S`3-;#Z;j
zI5wb(!_@CU6YqoGYkUh$9H#yen)nRp{5U6c+#Qx4VCn_Y#Lq+TB{4=5hqbq@(Zn}G
z*JH<`iNn;VqKS(`??Grs6NjnqM-$J3rk`zS;xP65(8Ra#K+?ejG;vsa`vsbKGqgR!
z1>KJh3m=$zAvEzc=sjO1XyP#SHfZ8Mq5CwF(Zpfuv(dzBk3sT#FPb>4y*(98`~q}6
z-gY!`nEL%_;wz!&hd)FUhpB&wCVm5YKe_<){wP@Zz|>2iiSLBYgIl4A!`j<UXyONY
zAn}!gCJs}dgC_nAdfsv$nmA1TG&FH_Xg#|ZO&q5FD4KX1bbZKkG;vt_|2>-c5$Jvp
zLFhfVu<(Jk|0U7HB_~1R*BVV6*8X=!6aO#`Ql3PkiNo6enP}p$_J28=IIR8OfF=%W
z|M#Pb`$6~LO+gdid>i7Pg=pfi_Wu?%aajBR5Slowy?qi*+z@(B={+=YnEIz^;u(t}
z>E}P1I7~eobbkpfUi_iwF3F>b!_=#xiF<NG%y&f-hqeEG(8L3v4UsG~aajAm98Db7
z{;xw5&xDRk%taG_3f*756-^x0{@;Tp&IIi*TtO3uwf}FUi6=nEu|K1U!`lB0C6Mrd
zg(s~2&yFTudk&&b9!(t9{#Qd2KdS`E7j|gku=c+znmE4zq+X6i6Nk0`Q_#fY#3AXn
z22C8+{%=MTSA~xI%|;W4wf`5PiKj<H+`kJ=9M=9nh$f!-5)wW)(Zpfx{|9K|`p|U#
z15F&({{N3Ae&Z3ud?jdpg2h)?A4J?9O&r$#cS95RfX<i2p^3xV|EXx=s-ci@u0<1v
zwf|et#0@7v!fg(kIIR7@7)`uL2cmutnm9DuF&st{&w`G(-$4_Hwf`TZiAzK8SN($~
z4r~82L+6uW;pqZh&!&YY4r~7#qKWU)g@jKqnmDXI9EBzx1U-kO98Daiz8+0{p8zC&
zm!XNn)UQJmXMy$;@1u#s)IUcPUje=Ulm&VYA1oYT>Uq$_y`bsM7)>0e-Wp9joDJgs
zbTn~TdpjRZ{4?}?`-y1cF!eLh#6LmD+jpah!_*%}6SuO3#Mdh{ahUo~XyUHW{+dVy
z#2>Kmfwi|~(8R6vAmx}HnmA0o8=CkD=so5cXyP#S1!&^uuS48F9Zejjem<HwEI%Ja
z6Nk08PojyJUxAqa8ciIg{xh0*qdLUDqLrxO15+=HCf)<R$H4_n9H!m}P5i@Lh<ozT
z#9{62GBk0C_Yil?Kof_lUw|gg4n6<y5Slnl{V6o@c<8;2AJN2N>VKk%|C<7FzjPJE
zU9j{6Yi}!~i6=tWN4cVj!_@ntiJyk@^Px1l`Q>Qhuc6~$^U%a$<}X7NkKYb){|Pj4
zSbO^dnm7-1U-Kt4ahUpFXyPu~kn|%1Jr4%vewca{G;ty5ImzB=;xP5WXyV7A>nlpp
z#9{6KS~PJz=shO$(Zpfx|K(`nuDlTUpF|Ufwf`@oiTCnD(!onKaajBRJDNDG{m)th
z(FY43So@z3O&r$#mqil~f%Zd{(Zpq;=Uf@0i3>x=kzCNk??C(47ImoZ**^=ycS94O
zDF;bE!D!+prjU9+8ciH}Ehj@Un)s6?5OZ45#9{rENoe9Q^Jk%nvq8sox1))NLhqwJ
zf+pT74~gG1XyRUN5cfPq6Nj}A-=c|gK-af0)I-7v7LN%$5c4_E#FL{T=1ZfAr$fh!
zG|<Frg(2pcqKPkswo9GR#054&!rvcF+!<QGN1}_*hqxyVO`I8;-;2@2eW3TaG@yyY
z;;R=;9G3oPp^3LELj1K5O*|7iFTW2>9M&&8jV2B==MtLuTj)82&(OqS{fM_{;uE0j
zjai}V0b%h7>-X`XiAO@mr?k<;mqXJ-AewmkO-MM0p@}CjLgFhLP232&zA*z$T%a9d
zPClA=A$0w71)6vsbX|H6n)n51KYTKp_^K?3`E$_3VdiW^6W@0f;{F|I;*HSprM+n4
zFmo=UiOWFuB|ShBpTrJv&s#KcSbq75CcYYa4n6~PJv%HOuR-_ch@**bhW2OW(8O7l
zA@=&Ci8nyU)#Gr8r=f{!Lf6^WqKQYJgoIlwns~@ANI5bQP5kFMh<oOti8DGt#FwIp
z-|>ftZ$c9{f!-&w8%-P*FIUjSIqyNtxs4`1Ck`V10!<ud{zo)%nE6~y5dXpA<)#xP
z90bwC=R@zCmO~SVnXir}4l~~YP5c>jUqLLII7b7-{rPC(`5PhbD@7Au0lf#L8cn<m
zdR|r|n)v655P!9!iPu2WXD^!g=VpldDQM!_K@j)MLlf_W?!Q=$CLVPYqJ9&axGHpg
z&Ji?m73jRcDKzn{*AR0qpozb;goN8QH1XBY^=Ws}#C4(T(x0P=U-<&@?*}w-2|<YY
zztO~3L(h?Bg|-u6>1PIX9z+C(xD1;36KK2C08Km^y1vl@O}s-K;?5v6@n<a%cP5~T
zPg?|0pNA&?2U_pfpo!0eu6sU=CT<8VhtHyk=R(i_zk(+I6*^w=9Zh^!A;dlZ(ZoMP
z@5PpFfy6T`JfB1FZP!8*-;)k8#}G~2P!l5Vhb9hFABrY!2c0)8LKBCzd#lmJVeQ@)
zH1W!%5PLh&#Pt_L;$;Gw_#bF{X$qS7Up9#PxoF~E(0#<K(8ML7>;E^SiNoB#2TdI2
z{$pt3|2rV=KaVC3Gv@}HILw?!XyQ6gA@TPbO*|dCKK2KixE}Q0HHKD*K3KfVLGS;S
zKoj5p2ck{^O}vH`5^fe~;zrPMCkHg~^-mz`BhbXBZ-JPffF|AvJy)v~O*{o!Z`PoR
zFM^)eHw#T17M_dI#9`sN2~GT{6U3dn(Zpflc@j<hFLYh&MKtjfD<S@Rhb9hl&v!KO
zCg^$lztP0&_Cnml1&vQwe0_nQSEYm|UK0gTZ;mDoYe)H`iKnJP(qROeILw`iXyUMN
z%SIDthL&T^XyQ|2A?}%hCJuAY1~hT6Z;)_1f+p?^9j`cxCjNyF(vP@_CVm3i|9yZa
z{vW#D=_Q)@5e<ktKcI>4T?!HZi6*`hdafozJH)-Pc$o{Wk2ul9cRYiHvnZOlBD9{B
zK@<O83{kI&CLXd6VxJ+JxGD7B84EP=Sg3kOH1RrUIC!9mvq1Ox2BL|(L)W)Qpou#|
z_rE8hiBE^#Lz;&s?giZk*M=s}3*GN98%-RRPBx>7f0+*npW|rauT&xNbq-DZ6elFy
z9-)cD)W1X%S33qVhZ&kLVewl9-M7nyCVm!r{<bQb`2E=sdyUb=VdEzbXyUN(4G%PN
zruPu{B%q1I#!rgS#9{sMdNgsE`R!=p4$$>lOVGq&<0l)@#9`wnJJH0opyS?`(8OWm
zC%4eV`xGGg_br+@Z2aUanz%PK95|rosleg|)*lo_6Nin5D4~hZR)wS=Ej00zDu}o{
zns_R7KHVQpyz>?$eiPBe*UpECH=v2b#$me9#C4$S$fu);&;A8*&nh%=@4t}rupLeO
z?;42uBWU84(EA`RqKU)Izkwzm4qaFL8ciIg{u7!w19X2e7xa8GSiHd03!;g42SMDg
zi6$Njy^qoWP5jPmh<Xn+@p;hu%6-tpS)t<|iD=@me3y$RerE?HzUt7#A3)c=x1x!Q
zLESS4O&q3vF`D>27DzhZg(eQmzo*f}^S?vfa|um62)fSxC7Sq6=z5zEXyT_LAmPT`
z4KWWEFEI67XySs<@>~f`9Hw3qO?)oYd`C2Kn0ik%@lV$w?npxuhpEp)6Q80DQQw9p
z4pZNUCf=<JQNIjL9HxF9ns`$_B)^<S6X%51@0ZcUo1y0-zD5(bgC1D<6HWY(FeLmL
zq3fq$;eQgk-c=S&yb8J>Qx#3zkpp6m6PoxW=>1b(XyQNYApXih6Ni;Q)o9{(p!@ZX
zp^59CfY^HuP5eX+MEnt&I86O3H1WIz5ce=c%OO}ez|y}MnmEiHIW%$ihY)jY(8OW&
zoj;m5%$#sE@kMVT>7)ux99EC?qKU)InTjSJwix1`b!g%+_1n<Im!5{GKaVC3Q-2*z
zeDZ#X`mbo>F!g`Y#08=KFKOs_KP;SK>Xp&N@0^90?}#Se2|ee^6HPo%1QPE_XyUMS
zR+(tx+o9t;ZD`^!^?hjKf1u~(u0|7wso#tyUcL$vj~CFy>!I!T8))JN&~vW7p^3xP
z|3ecOhn}A$-Vd<{7M`&A5mhvC*nEL5n)vC9kZ^WI6Nk-f1fz+=%!x)5?}EC&8cm$z
zAS7O9qlxc<o}acEO<W`#;+}(O;;?mMC(*>UVe3)R#9`~r-lK`b%=wNcZUG%P=7+9#
zgM}w-y_q<gc-0F?xa*^d!_=FjiQirV@s~fEIBeZrIGVW17Kr+MG;!FvyK*$~EB7Jc
z+>a&>TmLp4P2A5LV*YwGaoGB|?P%ie(Diud(Zpf%R@c$QSG|I`=RKM@tiAmmO<V@L
zZkB%{BwS(P&-xW&jyRgQnh?bO2590i^%iL2lc4S7Ff{Q5=sD_fXyU<s5POTz#P?-D
z?5#o*-^>ANM@>Q#hpoq(g(kkH6Jq`*H1X1Yi1|Cw#MeXHy_e9$+f*U;K0p(Pt?PS%
zCT;;ekA`&;YB)RgLhKbr6Ni~2jV3<%G{pTDXyQIH5OD`I@owljatUbSM?OH@(Sj!K
z)(tUdA(}XBo#9F}@%Qc!_a8(Php9h_Caw&f2YHAl4qKP_5>5Oc^xP!I$q@I#(kDzk
zCz?1fbX}7onmBA7qb8boRV>8)j%eaA^`2<r3H*@oNkkJbhVF04L=)fe9iqMoO&q4a
z3r+m32gE&#(Ztt5<7G9P_)!x`I^2&Yo;)35&M`FcAm}{Y3p8<<`VVO0X3%k6p(&{0
z4^uCNCN9wh@vjY<I840@ns_$!{-$g+@eb&?XEB<%3v{3R1T=A&`Wa~Ai_b&cy$eko
zwvO}=n)nvze9CP!aX;vJl8@2EcS746-_gV`K<91$qls&aLgGtyD#Tr|^t=YzuT(`7
ze<}h|XNM-f@drfQ6-_)5+TTe=6Te&wiI;3N@tGD7bNbN4kBLCsISozx2lV{j^=RT-
zq5Ijlqlr%tfTY9oXyR9{LELj4O<eXLMEy@R@k;3a4aR8@_rk(06najYGMf0mT8KH?
zXyTut>%)D~#C@UbOhVDb|MWxLnTIA08#kyy6NlaB)Ql$n{w2hm1!&?h^~=%3LuNqS
ze-cf+5}GeAqKWtZf|&mfO&q5F8=CkjX#Z3gy3P?6o@-nn=18N7^C?5pgC?3dY+Nf4
zO&r#*Oh6OYDubAxiYBfN?FVI{iTmY3!XY0`oM9%!oLy+*uzt-UG;u3?NV>U(CJs}7
z4^5mq2V(wrG;vt}lxqgWJXpBF%n?Ep{{cOB#sEzm)<1Pd6Nj1OjV7-A24Y_xnmDX~
z+K46&Gp7?xJS!jKuSIC$F!ig@#D7885gkSohp9h}Ce8+(KYEEK4paXTO}rnvo{%4U
z-U)hmild3Me}TB)6ipn~Kea^@zn2P0KVfL%u>NB#n)snZ5c8|h#9`{2(8T91gP1=b
zO&q3vIhy!n==}H*G;vse^9-8!VQBm36`D9q{U<c>*GC}fgc};Ju<(TSPbJaBVf{))
zH1X@u1)7#<;;{ayJDNDm9Dg+N*U<e)`Do%#q5Tk8{KMR7@)P3z<!I_*{nM>z;;??@
zUNrIBa**=sDw;T~fBG0r9A?gIH1TW`h<li!^ENPd!up%sXyWr0LDVawiNn-uqlqh2
zL(-cwnmDX~>WwD;4w^ob(Zpf>(`+>Ha_ByVW;AhF|Fj!T{3vujZZVoTtbe*1O?*AH
zJ%1QY9M(TQjV68-I&b<IO&r!geT^ob1D!W#hMtQI3x8ODlN(Ju02)3jXyP#SI%wim
zy^!$tLKBDePlM3JkLE%0dm5TJtbdw^CcX-KZbBQHIIMr#hbDdx+Amv%CJyVLu0<2)
zf~r4;CJyVLUO^Lw^(*h7iPuBtM}DG-!}_P}(DkRV@Q0bhk0x%y4+$R~G;vt})C5iZ
zCG^~|5HxWI=(*VyXyQrG@z1Gf;;{baTr}}A==~jA(Zpfu_o9jKVuiT>Dw;T~zj+r;
z{N4?S`mbo>F!g`Y#IvC5{zakZ8^OX8*58yx6Au!Bm~V<E4pVQ7CjR+3Bt3_siNpGv
zv1sDg|3TE3p^3xP*P)4PLDxx7M-zwjPv@hFD?rD8HlvBd`h&aB#FY<1%FjD!;xP43
z(8R@{{Tept{3<LwVe0wN#6LpMB{x75hpD$f6W0)cgik!0IIO>!jwYV53KCx}XyP#S
zJ!s;sQV{j)(8OW=(`{(tEx8c)oJSLf^-r&(iFZN!L9fxoVg1w3XyX4rK-?p^01^+d
z@PzeGCDFw9KZK|=LKBDePc6~JReT`s4@VP+^-tr`#IvCNjwUp5SpT#OP23xLuF7IG
zaajL!HJUglbo}HnnmDX~dKyjqqa(!qZ_&hI{nM{#;!MzW+TzfA{9xe;>z~S_i3>vG
z%Mnc+)<5+`6PFW%v~!Zs#9{r@0yJ@0f3qA-+}#fnk5kaZVd`h2iT{S4ud)|S9M<1F
ziY6|%A7cI^G;x^vS7_qXq5firwx?j>wsapP{Q1$ucUnNwtt^^2Y#q2Yn)plTJ|Jf_
zaUSSClt46b*gErkH1StQA^s{y6Ay*1Pi{pMhncemO&r!=-i;>Cx)b8B^JwC*bxPOJ
z#Lp~*gwHE9ahUp#XyQ+y<1F0Jed@4qhOKK7LK8m#9Us(16OV`HYil%dSUU7T6Njxk
z3P2OjfSxA|J0Ak(9$3G-3Qaw%AKi{74l}<WO<Zj?Bs|xkiNn@4?L-rYt!p}nCcYec
zuiPy(aacR{5t_IUbRPdJnmBA-(_b|4&(Lv00qD7muyBC&_hr$<Ve6W-(8T4kA^tT&
z6L*7-Bl)9=PlvWA!_mYisYA@kL=%UN|8$^<?}g4wPCyecGKHkiMQGwMa}J`3!}7&x
zG;s~+{?Z$0;;{8auhGO|>!W_4iNn@Mu`Y$=V^}!D)<+4UiNnm7L=#^RZMW#4iNn+z
zqlp(TgV^VdCJs{{geI;CUFVa9CJtL4Rfr}o1YL*Fi6#zPAJvN{KIs)CeixyM!}9Ms
zG;!GasQqZ-u=P&I(8RNTL;QOeO&q5F37Yu*9Ef{<qlv@H0Ul`h!Qu<HK1vu(+)^51
zuNIm(Z2gZRnz))8Bz?M|iNn-;qlt4v*TW>EiNn-qp^3Lb*P}L}iNn-)p@}O(*99#{
z6Njl^k0$;`5YiqvjwTLMe;!SIF?5{&Ihr_3{d+X=<0m2E!?PR`uCVZjt&b8x6R(tl
zsMA3chpmsYLKBCrk8(m2=Y!6t#G#49)<>nGiC^0RNk7eK;;{8m-Du)Q(0!C^(Zpfp
z&mJ`KozVMY*rE3xz`_AG&dHA^zR433ZpvulF!kDK;)#%GWN<+fho%2;G;x?Y@o3@_
z-H>poMH7eBn-kE)Vdl(06QAx1iO1b&;;{PY9GW=HoNH*}FQMy--=m4c)PF}4SAdSM
z3P8t!(8E~*O?(w}{hk?`ILv%IH1R7lAn_7|CJs}df+l_ndY*q1nmBCyxeHDFEOg#s
zF`77Re0UX_cn<U&%j0O`F!krr#HY-J#P1t4ahUoqXyQAe`)CBA^OmsigpDUlqKUUb
z&)qUd6Njm{M-vxX2yssYnmBCyISox5Hg24UCeEP)NpEdv;;`}ODQMy_bLOCl^FjAz
z??Dq^3|+T*2Ti;ds{RX_IBfix33{&rEZkt@#$0IPyP@l3l+eUs<Ie_Y;xKb8(8QIX
z>pTO{#9`yf5oqGGpyQ_nXyP#S6=>pm5s>(rfF=$bf1ZIR9u^8wzX44gHvYT=P5c)F
zB!68%6NimI-#`;T2kqZ|Kof_JKmR}zcT9$uF91DP7#1(E@n;Ei@yQVN25922cDn_d
zxCZnbxd1eA*m!aTnz$Nt|5_oMI81#dnz%4@ymUI6IBfiRKAQOFACU0hj3y2nf8LEI
zzKR2qk1nH$!^WR)qlsUDuCMrvCJq~a{)Hwk1}%St*Fx-pg+FZkSrJVfHg2qmCjML#
zqTdZo95((Of+h|#Ck9R2ViqKRE78PZ<Ijy~;#P_f^$XF&|3Swij-rXH*g@1kLKBCL
zC%-}yuiFDr&$JHWKUny{)N`SUCqU1OP(l-jjVEiNiF-rWkvgG?!_<4BiLW^bNk2(w
z;;`}LEHrTiHi-HrG;x^vE;R8DXg_xmnmBAcc@>(twJ0Qf4x@>~)SpHZe+k`x`UFiJ
zHvaquP5c}5zEK9~K4w_>!^V5r(ZsC|LHw(UCJs|?h$cQAdQV(1nm9~-G@AHx=sm5q
zXyP#St!U!*&~?0P(8OWm$y?CGPeAu~Uqlm!slSOPUIX11@Ec7WHvY^EJ$D}#ZgoPC
zhN%piIBfh`1x@@IG{0D&iNnU99ni$<pzCSl(8OWm&uM7lpP}P~^=RU-@#i))apiJI
z{4PNghmAk4K@;Dk1@Z5BG;!GY^K~?FYv{hq4`|}B@#i0C;%A}zo&=!hOu)h!HvTMu
zCjRFWq#UtA6NimIJE4gSLeCvaK@*3KKj)x{cL+nw??V%ZjXzIA6aNi82Vgy#IBeWt
zFPb=PJoyNk_;cvGh=*w6F!e9c#1}*7wYfGy+zSgg*m$xKn)qbsy}<ft;xP5*XyWpX
zkaQA)CcYH99w-J)TnRevpM@q48`tVY6R$UdxO*a+I6G8)KAJepoPB8G($Mv{N72M>
zpyQL*(Zpfq{6Z6l^>aBlL)--mPuY8raNt7|{|7zqLKscF8@hgX7Ml1K=s8;J(8OWm
z(p%BQXF}I?pF|UfslR|GZU#M{=M|bbY#jR|nz$8o{Ui^xy$18|PJf7hrO?D-=~*33
z95&9Zk0!nsx=zv^O&r#Lk3<uP^~clD#9`*=p^3kQ-iOtVCJr0No`EI~8^>ONCawcr
zU%C@b9M&E_h$fz|3kjbqXyUMO>^o@UpVA=p`+GET*to$TG;!ECHs@B<bO=kI!f4{I
zuOa3upozoAQH{~WVdKCKXyUMOU|%$G*f?+$nmEk-L^Sb*N|5@Z1Wg>Kz8X#37`k70
zGMYF{{VX)`s%en$--IR(8wcKrCLX2&QGXFl95xPo6-`_mx{mi1nm8=|e?t?8jRUi9
zLya%kxGo=>csz8ygesaiOuY`8_(K_p`<>CmVfiQoO&m539E~PE*#MGGiqOPi<D8Xf
z;(I?s{L_Ob4pToFP2BM;#QfE0;xP4_(8LAeA?i<|iNn-iLKD|7f~bFwCJs~o9Zmd&
z5hNY*Z-@8;R=&a1i=&BOfS#+Sk0uUNZ;mE@1iDTy1Wg<^4jh9fE(JXwvII>WHV)i`
zCJq}1?m`nk2wfk(3{4z14!jOc9J&pH;WU~!Y#jJ9nz$wO9L%q1;;{0E1-dUB7M|Ug
zAn8*OO&m7fC5I*sJ1<ciO&nJKTcC-<&P#Mf6NjC1=z}I+%MXe7Of+%WxLFyRILw?{
zH1S8!asP>E;;?a*8EE2-(0frgpozoA<+h`V|G5K6m)Fq5EurJ=f6&B#LFY#qcS7{R
z!v6?6gwKX1o}CEEFT!ZzuyZoy(Zqj3$3->K#3i8f<&J3Lnb37sVQAv8^GWj1#6zLy
zWLBez!`#!3CJrlaC!>kO##QE{iNoB#5>4D4dN2GoG;x@{htR}f_MSr%huM1zO&n(L
zQ#5gAXnFDuO+2Lv5-)$y#J609#G^2Do(C4cfzW$1716|D>MhX3zd-w6u4v*g{|2Io
z!~7eICJys&CYm_Rzr|?cs?hy|jcDR9cg{c)4{?I{cPW}U%$*z2#9{8-izW_p=Sehi
zm^&|{iQ7Z(oq32R4s+*wH1Xh*5O@AT6NkBnV>d(|7GGPS=icz6iI*lq%1I?O@nz6^
z1a#2E1#}?k!~#uR0(xJ98=5%G{jq4`9YGL#v(dz1>YLESnW5{TCZLJK)GtR9pLhl0
z|E*}^F!hJg#Pgv0kuRW$!@~0pnm8;xAESxCgx)j$4NV*to($0QDPi#f3r`+2@tx4~
zi>1)SpF`KdYodw6_G=lUi61xx2?tj+ahQ5vH1WUCeG6%5;-=7ZBTLZ4k3#!zHE80o
zLJ)hWpozos#UeCu2WY-qg(iL!dXB*%G;vtGTtE}AG=`+B8))Lo-68JzfF^DNz5n6|
zn)sx5kaR8py^jtSUoiC&XyQfCbC^xh#J5A!gDsl4J;*=?28K{HahUp8H1X@ubFr$>
z#J!;5)`TX`2tCJmKAJeJ99xSf{t+4uThYWXX+gs65}J4x)ZSZY;<F7Q?VRsu;(5?`
z`Hv?4uM}dw4D|dnP_TfeHevG!Drn+*(EZeoXyUMPH2_WA4%#n{LlcLU1375o$DsEC
zwV;WcDnrs$51P2b0f_i4G;vryU5O?R%Xb^m#3i8nS&pKK!_=Qe6MqZM7thedVfpk6
znm8<<{y`JJE(~$M2y`7NEc{{lR0&NSmQS_N#QmY?;yR&;!}4hWnm8<<Mxcq?LGNoW
zKof`My9zXMF6ez^6VSwA>Sv&dTR_Kkx1x!|^4(rEaUbY8rB~6!Ve0RqiQj~-^ZbP-
z4$G%Z2O#Mk7S30o=lsi~iNo@#E}A$jpPHhH>mGoVS3zjvuzVVYCT<JeM^=s|4$G(Y
zXyW<M{StG~#9{e#37YtpPDr{sh$arprx(z~e?!j)yN4zY%cpP9#5<w)zWqWIhp88Y
zuKR<9^O+lvaF<6Dhp9J16X$^LUv@?lp9$TE<AWwXA1WS-CY}oIPsO8&e}%5=D@GHC
zopWA|ChlhsiQm;|;=iE#i+7=kdqIj}hC^uL57{6RPtn9>q4)TFMiZa=6B3WV(Zp3;
zAmOQW2tvcc*%*3$uNIp4MCdt1zG&in&~suV(Zqj1@AZg76Q2v6=SoHs|5E}9pKLVo
zAJF@QD$vCLLGQs?f+oHTx{q}Ynz$Ntee6y&aaejjfhK+hI&XdfP5e73pcoh!?xKmq
z%z1+*-UJPYFKFVh`@b0vqlQ1sU%F`GGj>7Z(G*Sm4|E@#6Ph^8J%MQAuF&zUNHlSN
z=()aWXyPz)O3}o#pF-SIiza^gAtWBV(8OW>+J+|n3wplUJ~Z*wmJst#qlv@Za|=!U
zrXocBBQ)_q=z8h*XyPz){-KHgf}ShK2Ho!qif(Xw20BhCj3y5Ampz&|Ed98niDyIC
zSBId9!`zdMCf@fK;;(EpaVzL~VijoOF!wA$6Nkn78Z>eBbrAD+qKU)Ya{^6V7J9$u
z1vGIVX!zen6NkBn6S|)R7M_CIkaQx5CawrQXH5=G9OfQfG;vet{o1Bz;#@M2axw*7
zd=13j95nIs(DM^!qlv%S4GEvcXyT7DA>x<N#Lw73^7BnJaW3e3>t|@<uzf4<(Zpf<
zYdDTU%!7s7`wED?{Al80(0hJm(8OWptD=d+%(p`mp9j5<*cDB@9XdW7geDF%KN?LO
zW_}5pco}pZcnz93i#f!fooM1P^CzK+!_41_Ccfi1Bzz8_iT{M&PjMDa9A^GQG;vW?
zh<je3iHiwB#J{46#~48D<vR|MhsD?DuMoZ%n)upnkaVbwCJu9t4w^X3zrkqYU2PD1
zqtL{sLf0o(qlqUnK=MTsnz%$Y#GH9(;tJ6F*_Wb;=Y4{>{~((9lhY9Yo<tMxhTaEp
z2~8X}{{I?HJQ#XT{wFl?AW4Y(`A$IWfrayT=(*XVXyQ8<A?`Fn6PJayhb_^>zg&Q*
z4@DC<hOP&QMH9D#o@bqfCJu|oVl;7BJkCNBuZ@I+|3WnJd43S_b!g%+^ADkk@6UpS
z%SkkGG3Ys**U-da>GnOE_)_S8itlLRq0sw4Sx!RifrUTJJ-le*F#n37iDyI00TVRw
z_t5*fY|zBBp!byop^49g?zc)r6W<O!-!BtQ{5AAk(=s%1nEUI|#9{95Kof_#e;Jy%
zV;&^^tV0vegWeZ&1Wg>~{>y0Mn$Yp9+i2n!7edm*6EtyHKKhF$ZUjB|j|Do82#c>Q
z=mef1nz&#C#C!!basSH@e`%nJ_e1ZgF+>xGxyKbvoW~53e|^xz&7kf1P&9E^_-CSt
zt3lht1!&?X(DRFG(Z!+nF-=4hpAGF_%s>+thu({`6ipnKU-qGitH(m}!%;MGUg&*5
z=g`Dq{(6KaZVg@6@e)n^5cJ;jPiW#WbJ(EeE-Ze##UbwDM-xv_gNTcviSLH)f7eG7
zSAn+A&C$dcWkJ$OD4MwH6^M8&nz;01h`ohq;;{QZ>d?et_kFaXi6=qlOBSPv+d}K#
zRcPWHq3di9qlv@r-8h3L4!d{bDw?=4bl&<Vnt13nh`%19iSKoTh(ARWhpp%Qj3&Oe
z9ujW9(8PVA<*?Wph<UL1O@Q9VA&Vxi2)#$i5>31TdcL;<nz%a`#NHS*@rYE2eaUFz
z3efqcdUSE<IrVL5;%lJmY!{)47tVs1zY0zK2=v~!?P%h#_&SXy9w-NK|7A3B3+TSE
zJ80sta_Iw_cqH`v<R56_x1K`GXFUsXFD(3F?%_idhov7`G;wX{`GG2E;`z{VHdi!p
zKj=NDK4{`m(EEHt(ZpfpKslQD0qA&f9h$f{bl$ujO&n&<N;GjM=>3Ts(8NQa>0u|D
zILw^eXyR$6kn;Z#ns}`Oq<;B_CLaF_67H<f`WzPiH=*qrMKtkV35a@4H1QPZ{Y_?Q
z;;?wMM-zv|qX(KeEd9iwiBEu*ODSmLg%ObSQ-~%Gv$qOO9A<AbnmEkf>1g7|q4yEb
zM-x|egV?(UO&n(LRy1*#y+_c*`<)^2at2M@Q4M1LO*C<s`H#@VVdlR^6NmZhKbrV9
zXuPvQ&l!cq`<@Mu_*Fs^4~O0>q=hDa6WZ=FM-zv+#~V!?W==4gcsKNZ*aS3jm^meA
z;+LTJ{8plg=R@m-1~l>8ArODfKof_lpN}Sf2fEH<JDRu|bY5>Cn)u!S5c992iSt0)
z;m^^;Ve$AKO*{m;4vPH(#5`EMz|>2liL=#1(vLivxFGc2B6T$Jr&^G7rHv*&3p##n
zj3$1y6=J?Qnz$MC98`NWaenCiq|RvKBGB_dywSv0LeIJKM-zW`7h-QDn)rF>IgIIO
z;sS*b^;Kx%=Fs(6bI`<tpyy<+L=!KwfrQUiG;vt???)4loeEKZ22C8c&-5~yxCeAx
z<2jl*tey5BO}rmEKQ4C>H9fFRg80`AO*|GF{<di1-q3NsC^YdI&~q;n(ZrcNAm*2#
ziSJ$w5wAuQw}bW{XP}8kL&v-3qlx!I-MI%%e4;lbJP)IZ7eMcke1Ikn3+Lx(;vvv=
z^(@f-0W2SxL;cH*CjJ>ZPbP;Z4oeUEXyUt|^KoWq;<eE6Pfs-QI37s21)zzuLeKLl
zKoeJk-ltZHCT;><r`>=iJ_(v%CZmbN((PI_aZPA@eixefeds>fgJ|L|D<ST`iY5+I
ze+Nyx4|-nBS2Xd@(0f$>pozoImlVB>n$BVK<4S1a^Ee^y(L@u^fbL&#LlcM1*9W7C
z!|o+dKof_VpN=Lz5jxJ<f+h~z?>P}o9JUW)2Aa4NbR29KnmBAd?Qt}5*glAJXyWR@
zknnngCJx&N@fl5g1N6QpDd_qySiYDd3dwisXyS3ueU8Rx;t!zvdF|1}yP)Iq-e}^B
zq32YDqltfl-jBQxO?*l+#9uqn#C6yp;&0Hz*{?y|{~1lZsRE*&4Z2Pf=HFswNc!PL
z6JPQNVvZu3xP=fzy#|`N7Ic2u5KX)X+77os6L*HrFF2x!&xf8H;DIK70ea4SAe#6r
z=y~`NXyOXcepVuyI2&|aE(1;c8uT2PLNsyMK9?pmaaexrLlcMPqgiO;u=KnPO&qp<
zV-uP<ET8T}6NlxmQ)uE$&~dZtXyWUk;|6ch#9{5>@95$xkaWTd)dx!_uyslzXyO;3
z>-}WV#Mk_Wq#pw`ahQ4wH1Xrmb3+2r#9`qOk0uUVUzCm}&h!+LKI_rMVe!?ACJtL)
zG!;$!0JI!fizW_RFSHd+obx#(+|Htj!_;3z6F&j%Cw@W`hpiX-g(mK01_@6g=zVLj
zc!8;xLK9zZ3Q=#4CJtMNV~-|o`V|sxF=*nj^qGYw4qIPTgeJZR+7InV6Njy9nvN!}
z0xg%epozoQ7wth4KLI^Y<|djrZ2i(hH1QtjeCIzjao9RHHt2dESa{k%&6h(Hhs_JC
zqlqU&*DIQ#iL*iPNpe9GhvlPSG;vtIh(;5ygWf}vk0uUNUydez6uQ280-881AI(D(
zhvlPXXySd)ak+hH;;?)KTPFnzH&{Npf~GzRy3g?qnm8<9d_fa`rU1!DJkb6$%zT)7
z5j64kO^|eJh$arp7nW$^AE5J+foS3|^^s`ePya*AFGCZD<)b<@ac}54nb~OKuza)<
zO&pewHlm3?QH6|OokJ6c<)dq8;xXEg{QenD9F~uMqlv$^g@m&NbpIkOoMHJ$0Zm*C
zI&N%>CJxI-u4v-xq33eMqKWfB+fk`#;#;Bnri;<U3!(K$JDNBwKTbdshvmolXyR7T
z^AXmdiEn=n3AY_+;;{DH5j63Y(0b|un)n~+{UdkK#9{5aXK3QbpyL3a(Zpfy`Hv<J
za}W1zNW8(~3+5hiG;x@Fl+nat?$JdP|E~*4=T>OqF!#8jiNo9zgeDGiPaK*!%sp9X
z;xPA=po#B=j<+|WiNo6Ay=daFcKA#*ahN-oqKU)W;TzG!VeZ+DCcX-KKko@NahQ9q
zpozoW^8ig8=AJib;xPC8Kof_#hY7kq6c+E-k3!NdKbknqJ<@36F!!jViNoAuj3y3q
zk3E_=%srlH;<KRVEQO(o!`zdECJu8?9-27JJymGpF!!{fiNoA80ZqIUTK>#M6NmNF
zm!OGDh(N+~2bwrc{eCp@<IsI8H_*gk{rdZ8;`z|=u^(vSu=<qsE^5Ap^}Bh{#Iq(t
z)M=uL!|Hc4G;vse#2HN-X1*7i_<88M+;lW?SihqLO&r#*uSOF;039EjizW{12dzRA
zhxO|>qKU7B-oJAmO&r#*zlJ9MLj_Wfy+ad+-4Fg1O?)o&ymWEseYvpw1-l<y4o%$Y
zJS3f%qKU)K<w!;oFNdB#GYw4~)=!^{CceD@V*Um+aaccnJDT_*=y@`y(Zpf>^h;>s
zKG1oM+i2pje)=OcaaQQLE3eVSVg2+^XyRGW`IO&i;;?=?6ZAfCSU4LNL*k1YO&r!w
z7eW))lZ2#yX*6+IKV1h+9G1T<(8OW+#RW|qmd*pv#6Lmr0gOcxhxM<E(Zpf>>smDN
zH_-c|yV1m9{eoF&;;?r9A~f-mm5_9@4NV-Tejl269dsP{I+{2v9G;?y!}<kp(Zs!>
z?NU}~dj}Seuy7Ve6NmK+q|wBkp!+(F(Zpfxd}}oEQs{c}U^H=<`e-z9Zm9YSG;vrv
zzX4601$uAD3^Z|=`UPm>-CU6N`Cc?}Sij&Xn)m}<i26rp;;??f2Q+b5zu*U&_-<85
zyo*BbZGeS8tY09DCe8)jPho{74(k^<p@}bsj?2ZPiNpE@>1g7T3=sFUpozo!1wClu
z(a>;Sf+h}Y&#y%jhqdSTpo#y7*1reQ#7nIp<-<8NaacWm6-~Sqy3ge$nmA1T2Xt}h
zel5;N5PM+Z53BbD(8Pa!gQ(L)6Nlv&Gc<8ny=;pnUI{%nGYU-{mVeXH#9{S*37R;}
z{Ax7u5OqlUoPj0|D-V~ViNossHE7~dR*>@i9GW<+-oK3|4y*Scp@}n?L(E}-uIGY<
zGpyccM-yMl0!fGRXyS6v^Yhiv#I0i?=6j%t!_Lq5M-zYk5u!c~O&nJ5x1x!|&d={b
z6Hk<ag!5uFahN$5(Zshw&x2)w?lXgh1FZePjV5k>6A}(`XyUN;gDRT%VrxkHv_un!
zwI3YN#M7YrRy@(fVeN+iG;wk0y3I&5aaj8y0ZqKY4C0<lG;vt_p#V)h(FPJPm1yFy
z_Co`j`02wC^_^(qu=c|&G;vryU4|wO%Xgd5#9{emADZ|92Z+B;qlv@X4-e7AVeN<4
zXyWnE^8$XNiNo3t9MExPSUQ2V2L#Z>e>OnEK?O}5rd|h4d_NmRy(^kHEF6N-#9{4+
zXf*K!&~spl(Zpfl+=wO)Yd>_Ni92#Z+_Ml(9M&FKi6(AX49OP<(ZpfuPojyt7D3cM
zLlcL!2i~EH8$r)yWqSsRXIS{d)bpW<=Ro&^Yom$7+7HHP;!C0Be*n5Tw7(XICJt*q
zq@jr$--Gz88BHA4e&|LM-w!>%dIg#|to^V7O?(aX+>f(p;;{C^RW$M0dm--mgeDGa
zKm0-yKLy=qEd-r!frT@y{UD7d4r@PXp@|=nfRw}fXyP}Z=WW`ciNo3h&S>H`(EFyt
z(Zpfu<Iu#*p!5CZXyUN;Lmis<ENFQ(9ZejTUzVVW!|M0dXyOxHA^GJ5nm8=~UPTj!
zwI3d#iNnl)i6-u72ub&BFCa85USQ>+Fq$~5{UC)V?hC!I*#=D<)_(9r6Nj}Q0?@?E
zI3VdN4^14_eker~k9iMq_Z&3w06j>!oktUg)xX!!#J!>OOfS*IVfF6^G;ua)`;!Hl
zk73~ktADxC#3w_?kwnnMVfC*xnz#WU#9u0C;;{Nx8%;bIx_{6FO&nJLTBC_)K>Nim
zXyUN?*BedTgawlCLeRuv^=~SgI4qqPqKU)OZ7rHOEWLH2i7$no>pcxk99I9XK@*47
zzuVBnfA5B*huvu6V$gdD51@(LL+|H0izfaTx_<8#nz%W1KI<Wxcq(*0?j4$V9V9pz
z{-TL1DL^Dxq36NF($yJgIUs~44lh5^#9`&9KAQL;=zT!uXyPUpA>reKCVm&Xf6W(7
zT%`k&KEu$&VfJRBi9a!gs4qkl_dEj0?{#S6u<+?c6K{aFd#9p_cU^+Ge-WBEEPPg@
ziNoA^08Ko<7Gll`G;wC=eI*ys#9`*&LKBCX{}D|*7J8rfUo>&pzGxQcx;a?9-@OY7
zA8s^pU+8$9IGXrG=sHq4G;vdC_^6_ZXF=CB*`bLmK+gmBLKD}8p8p((Cf@%G;?4*(
z@ng_=x)d~VzYmabE<h7!gYK)XLK9aJhoqk_H1SSoyv#xq?~aD3UyUa28wU~JjwZel
zIzDh1O}qoTKjjvh_)+M-(@$vPOQGlR|3nl23U%i{H1S1B5chCH(*-Qv*FpEeNuY`A
zL-U;~ns_GkJU1gWakmGMc(F$lKMlQa#UD*v0eTN$0-E?V==$(tG;tm1dhB{M@j1}@
zZ+g(gg`oSAW}=D1&R^PzCcYsK;{L;E;+LTNV$P$9i$U-8et;(43mwmSgC>3ix-a-A
zn)qtyecWu&eI&4Wi8u{Ox58-R8EYZp3TWb|q5I%;(Zn}E_u*QhiR(l|{OgV;t_xj9
z6oMvh^#)>ZBAR#r3nX3Tp@|=Xnp2G?KD`QJZwH$AR!xZcQ_;kyLG#ffG;z+O5cTWP
z#IHj8`+LyDzobLdpF|UPfsUtKLlZB9o-gqjP5c>j9sUP2asI~;fBi)hSAd?U#Ptpm
zPO$hr2d$69(Zu<o`{h;8#NR;A{V+rmw~~g~YlkL&9J>G38%<m`0pgAbH1T?9_@ttV
z$3pL~DMk~&01f8}XyT>N@zCXH;#$ysD@V}8<DvKayhaoM1U;{n9op`Oh1-4T`Hh-r
z;_6WUx}u4nzXyr;BsB4b(0RiwH1Rt=knm|n6SsoiYc?BA{7WK4{R%Ykbm+MR=h4Kk
zLiYoHMH5$m&W{U0@8^X1ml-<WXNM;4Pz<p*3Qc@dC`7yvP5d3mKn4be$!Ov}yCC5+
z8%^AA2}FDgns~-?i1`=L#Ap76h<`^DuRR1YN8%$y9^?$rIW~>Zdj#yz#D6@4q~~}v
z@q^M3bE?tA%c1M&rlX0U@`0#7j3$0=Dn$Gqnz$JBUaFsH;_IU!>P4XQs4(}(9fyeP
zqlt$=!_x~*+#T9aY(^7*1HIp50-E?b=sE3k(Zv5l_h+p_6Q8#M5^mek#8sg8x*kCj
z-vnKkco9w9+#F)gJv8xDXu5ihCO%;zMEwsm@fv79jum>&IxO72Zic9rKoegBZLjE|
zi67I4sP{t?mx0!6d1&Ht(DP3F(8L>|_Z#j)6Q2m(XL}V*{4aFA;5(YQ9dv$57`m?x
z=C4U>A?`Fr6Q2nc4?z?E^#qcBO3}p4jzPqyqKW%M>&G={;#;8oh_h(o|Df&dcWB}p
zyddWDL(hYOxqlw?UUdUB@k7w_A3V^+ouK!F2cU`1g09O-K@*=2ZMS6O5O2mI-i1Sa
z5t?|=6^Or9;t)TGL;M5|@ds$)J2pbhe~v@^KMrv=XnPPA&M<T2(8SH5>n~Mth}+^2
zcflbZgC?#7Jy#(ahj;@H@pc^IOVGsSpy~Dinm9kS-|-MlJZcXlzr=h;tru=X*MDZ9
ziC@x#s4GDe=Xwl@mj*QPPU!xf9yD=>jSze1qKR*W-gC4PP5eha#NMrF;tJ4x>j%-q
zS3%E-J&Pt@b{*o*n`q)oe?r8cqKPv?_uYI%6Tb{S=kPC@_!Ve5#tFUm2A1A5p!XSx
zqKQ{R_f;vPiNA!3>!OLzgzf{iL=)GB)-SGT;@!~kt3WhyIq3amv1sDj(DC6+H1U@P
zknkx*6Ss!8HyY8z4WQ$Ay=db0(EX${(Zq|P_4raW@%CAebOO6)3>KbY(DQ2cqNxwr
z4^e*-O<WAxkG_f~ZqW_#*F!Y%@;MN5-lB=mh2F396HR;@bRQxs^u7+5JJ+Z~(ybtx
zcx)=fURgBp9nf(GO*HYV(C{%u6IYoHai=4ixH5D-yf2!#AvF9W(Zo}s=BJ{GS3<+T
z5Ka6bbiY6?n)qs8h`&0~#NR>B6`6`AE(}d?_t3<->mdFLfsT8@!t)MvA7vt%_(|wF
zGkIv@99|G}s?o%mpz~!NXyVhM<HJ+Y#N(jr$rquC--GUNU5_SiGX)Y3d(gx=1t9J@
zi6;JO5k&kNn)pFzJNz-4xE8d(`2kJ*Hnjip7fpNvH^e<$(D7hcc*5>E6Gsy_hQ^Bu
znz%l+e{F~+J{fxdtR0&8Tw930ywSv)p!YvUpovFA`+ccs;>OT(%Zt#&S3=WCJ(_qE
z^uF~TH1SW+^O<L%iN{0lDc*)AUIpD>c>_)S1GIj8f+jv4dT#0mH1XTed))q@i5Ei4
zVGihho3MBhgx)JBf+oHex~@P0O*|WVkFqYBco=jX!wOA&6Z9MgcQo-Iw;=HqjV68%
zx_>+!O}q_y?p6t!xc_2^IgM!Iu<^h?H1VSjkn}klO`O#lBEAAmyzCgn{H<u>UeIx^
zLulgc(0$hD(Zo;whM0dBO}r=-V*Wogab4)Sf85Y|4;EkI(Dh4_XyVz>@qAS@@h(+J
zz2Jr>4l_R(O&n%^BAU1e^q%xwG;!BTi2FOx#4kYi^-o0;pELpDo<(TlwbLNt>(Rv1
zq2mC1(8Oz?;d2X3{OL<bIKM^{Uk>djenAsggO1lR{DasJ3+HFh`(Jp_#H~I<{Huv3
zz7D!i)(TDB5_+zdGnzQeUVk)kn7z?x;xKzF(8RYqg1DyzP5kO>i1-9F@v6xX@tJ7i
zTG00JA~f;8(DAO-XyRv}>*}|li9h9qn7<cI{5N#}`7t!{mC*ZZ&ZCJ}vqI)8Z=i|8
z_W3_V6Mtn4iN9B9;@1oz>ESb)_+{w2&_8J6(J2u3vqI-3VCjL^9%4Qpns@^A+yikm
zaUbZom;##k3`K~)G||L^q3aus(8TXU*L7K=iSL1q*SVmH+d=n(_@arYLif3cp@|DZ
z&&`fU6Tj08@oxs2xbF%`cow3G3qkL>s6rE818v7Pqlxc<_EUP$#5Y67g{Gp3cSFw?
znujJ{2VM8O98LThbbr<cH1VVei2HY<iCaL=n>~ako()|WdKyjqT{y&?D`?`i{19>2
zxks?{a~oO@K0{Mq1U+ZqJ({=zbY1-qH1R{wbI%x|>#SkspM#cTTxjC2q3f@N(Zp+^
z@gjpJ-Ue-VsiKJsLeF{7LlZv>o#!$~6Oa80$wv-o;%8n#!p9R$ylWdoeGr=XZD@Zv
z8clp>AjF&$H1Qq(A?D<wiJyhm`(<e2%fle%)T4=41wzc}KoeJnwg)DniQk2uk2woX
zeCZB|Ig8Q6uR_O{)}V<`fUcw3iYA^7oqyklCa$*tV*YV7@h{N%l?!O%v!UmF-b53B
z3@!H_p@}E7L(G4TE)Jbf`GO{X3OZl#7fpN%bbOc%dY&IF-Cl;C3(Ais?g%}1R02)>
zA2eSpqKUIX+tpfV;>)-p<*hNAxGFTg*`SI4fZl84iYD#}-AC_-Ce9-cNk8Fe;s>GU
zl_j8wGeGxqW}=Bth4!P1(8QlZ&wHsx6Q2N`$813pziI&SZ!enoVQ4#T8k+d84v72b
zqlp(fL(2aZXyTLqK-6zU6R(JbsNaPqei_=oJB%i-0h$zIU|=|dCawiNH}Wc)xG!{n
z^gT53PtfpxjwW8R29j<+po#aJLEQfnO?(>k98o4Fh(1{QEQ8)F#Em8{kOJ|q2%5MU
zbX-CfO?<&*h`nlP;`5;MBl>9KD$x4f0!{osbbi4RO}tJ667ODU;w~HzcLt-0KY*?u
zjzJS&3myMVMH62K9godJ6JG$mC%qg^JQg}0*nlP;a03z!ooM2VOCjQu(8Oz@`}=02
ziT{DF-&lesegxXSUyCMQ3%$>G8=814biK!ZH1RLcb-yRj#Lvx#q>qbe;%YA-;<wPm
zrv*a7|1p~Qb$y6`-=K+qgc!r{6;0d}dQbE}H1SQm5cAoYAsS)nwy_Js7eEs~<^mCy
zL=&F@-S4b~CjJ__j$IpFJRD-L37Ys(Xg}5#P5j+<h`nxT;-1iP41YB7_0ak52sH6k
zZjf+GL=z8&_G_}x#08-9fW>Iy6O1AGr3OvB5;`u_iYERMx^ArxP5kOsh`*+ziE}~k
z-CKYrZZ;3%{*`FrZ>k~Txd}}?5E{<A(Zt&&A?6%G6OV_ke>;mN?yU|{e+^B10kr*p
zA5DBAw7vHNO?(^l{*;es;_sp3X1~zHBjq9C%nY4hg{9A2=(&76XyW3~`6E#@@t4qb
zdU9yum7gL0Qb!YKxetjK12pl9Oh`CeqKS7v+e=Pp;;k7FbG*^SZ$tNqhoFh`K+jEz
zMH3GdfY_UcCT<N~pOcR!z6*NqZ3UY6Bxv|HqKUUd=f}Iy#ABiB944cQ2SCp&o`WXd
z3%%C{wto&5Uo*Zz!g(E<`XcCgiQCb{4?y>M9Y7PWYJh~pNi^{WXg}o=nt0U_h`qPb
z#D&Ts<~%_Y{{lT<@hzJ8Vo!+rZ)oDXp#ARuXyR+3`I-Yd{|^g?LTLFTh$eoq4`RL)
znm99b{6QH_yb8K*Ob1Qe2D*;X6ixgkv^@!1j{tMe59oQz?r7?zpyTiXXyOdeaxxN4
zJRBNsNoeBn(D{;VH1RjkbrL0L;%A`ws1{8;zycDFZD``Bq4N~|XyOZ?`=e)|iKpvB
z%9Dj?;vb;vi&mkDyF=$qHlvA8hOV>PgC?E`z4zoOn)qL6zxW)QI5V`pdL2!CC3HUG
z0h;(hQHc9rqKR*Vj<<h86L)~#EBYHv{5W)9EerIX0a$tnUIz(hUNrG&=>2zMXyU<8
zzC4tMnez_1ZdC(Kd^z+U5JNQa<IsF+g(hwWZI?QuiMua{xYGwsd=|7k3`G;a20cGE
z4o%$k48)vtH1W5~A?0=fn)rHXf20ykd>wRsX%m|GmW7af-Hj%`2ii`Uf+n5`?XS&6
z6Q2g%$FvMheD@xR``4q1&xFSJ4m9zJQ1=`}6aN4m$2^55ejGZkdl^l98T8)RJ80rJ
z-$UH<6is{=^jzh4XyWG3e%5z1aYyJnF$U<pI<Rz=23=pui6(9Zod*{}6L*5vchYF$
z(_$g<tAZx3xd{?qx@h7Tpz9XQ(8Qk_LHuivCcdT@BJP1Ez6*MPWgwb(E)yhQN1=%e
zLHA!Lqlt4u+aWn<;(MX}h*C818BZYotwR(413fRg9ZlRL5#s&{XyVDx{R=bE#B-qg
z$`_%D&k}_AYc-m<U<<@OThPScLE9U9(Zmlz)8{cXaoaXXe4R%VSI>Zm-#`-=fsSuK
zL=z8;fvA6lCT<U1hxQpweCI?+`20Z=e+}J-!V29l2uruR8zJWNp^HP;=ZK?;|5b*B
zn*y4+6EwYPqKO}co^Ni1CVme(-foR1{s%gr<$@-D6}s-)7frkfx~?V+P5cw|K9qPg
zaVZ%{{AQqu`$6wBEkqNSgN}z+p^2}&05PW-O<Zd)B>a2O#OtBwluktx-vKRW=AnuI
z3V@ii98J6jdVk^uH1QM{i29vq;sMZcp+jimy3l)1PNRvR$cLD71x-8<dd|^ZH1Q44
z{QeA0yb8KL=RKPEedxWwKhVT`pzddc-X8@^pO2yU4sfA~KjMI-Lt!-WEa<$O44U|o
zCP;j#qKR*Cf{5#(iSLE3CoxA8-wJiN1Dg2qZxC}l(Zo+d%cUSRaXV-{Mx%+pbAp6_
z3Ys`8^gMxFG;!UN5cOqf;$hJGq8?3rF0?-CKoc)ZgOmdk(Zq|P<K45+#1*9=_AW*f
z{|}wlSc4|c2_5&|iY9(Z0AkKQH1Tri`K8Cv#6LpUja@(!-v+(!?<ShKEA(E2M`+?l
zq4$fuMiZX_9q;{uCVoF262E`Z#7&|5MA)F~vta4A58998M-xBk3Nc3lO}r2~4zGwN
z?i~YBuZ1S=4jtb!MicLWj$_!MiTgtL1Gu7z&xiJ3{LsWVK+mZOM-y*=-V2a`CVm-u
zk6|X7cpCH`x*{}jBj`G`YBcd2=z7!^G;wd}dCR?M;x*85+G%LwZA&5PYCf9y7U=!N
zE6~I{p!YItL=#s@fS9ujP5i@6i1=YN@my%X><pTCvmGRVT}2Z&g5DE)4^4b8bROh6
zn)qGldY%tx;?B_h9Y4{;d7<f(i5rrRVCi#_3WU#%Cf?@_ai<8H_)F+`h%B1;GwAvO
zH8k-O=)F_=XyPB`A@*9JiJyeFR~*sA4?@RPywJqIErf)BFq$|EbbVM1nz%A_oFNrW
z{1bGZF%M0ARvE<nay0S9-y!aAKoh?O-RIbeCcYbb4$>qv@#)?W^Jk-pKY@<3EkP6i
z3f*777ES!W1H?Vs(8P72=RfX86aNF<A9n&xJPA7Qa}iCP9eSS3Ei`dwW=Q?}7)^XH
z^uEhCXyQ+y<7{8i#E(Ml{f8$047#qEod@DSSi0R0?H>uCi915)BP7wpH$m4)Dxrz5
zh3*^GMicKghQx~rns_+${C`_C@igc;18!*I$D!k^{%GRspywGzpo!~2=Pwe`#BV^?
z<7J_V!@|87P23kcE?0vlUI4wnqZLhDx(AZq`_RP0p!Xt8M-xwi&Mz-O6BmY#8>~bV
zXO)D+-zGHiaOgcIyV1mXq2t3x(8Qyl_XM0p6IX49#Md=6aSsuQ_<c0-Wr`60zCaUS
z2Oa1Ch$dbEt*3sWiQk0I12RL`g~8J2LTGu#gC^bpUGFN2CjPMk;!Zg<@y+ug?o>w;
zZ=V7YH$W4=SPBuhL=zW<p40AxCe8}IZ`~VB+z#6A4M7vn2!*&a7EN3bdcJxZn)q&L
ze$Gb|uY}HrR-lRhDulSd5ly_V31V*-nm7xzy*e39+z7g#cMh6(2ekdO6iu8NdM?vC
zH1QV~A?bEInm7k^yz2m(cnoyD`y`sUICNdXB{cCc=sKC(XyV+^@!ltB;;Y3V?s<zQ
ze)}gxoDZ6BVCnD;bic4Zn)tC6NH`~<iBE&x<1-6Qd<S&AbTOKE2=v~){b=HIp!@eP
zpoud~fw=P~nmEjyuV~_t(0Z8-I<5xumkIPdF@7|0m^s>L;>)4q`Q~WiXQA_4@o3_e
z(0g6$(8M#L>j2wuh|fe5-v>2kJ(~DosQ587@e@$-yJ+Ieq2~{%K<5)+;UECr$7+ox
zp1Bngzu{=&!qEL4#c1M|(ED_zpo#ZG*LQ726aNA|7x4y~xE|D;H)!G)pyM__(ZtQ5
z>t=bN`-5TrvV@+)po=EH04nZ_CSFtk@oz4gcolShyai4CA9S32DVq3S==o*`(Zo5n
zLCT-IXyTdB^#27-d@r<K6A^->cbLCAq507SP22(MFMl-gtx$8a(8L>|{m*hVanTtN
z`&!V%EurfGC!vYoDS-HEKALzO^c?TyXyUJ+_hOtw6W4;Cw|o;#{13F>@dZu%JG6ho
z3SEx|3m?Bmh<n7*#3iBkTPdT7*X)O=*GCg~fbLIpM-#7wp2HA~CN2#fcZx?7SAdR-
zW}}IJm4(<_hbG<$ofnvbCY~1uQNJ2Zd?|Dv;vqEgjnMVXH_*fxOCa(49!-1=w0|lH
zUFQM|&$UqXMrh(*(DSo=(Zshx%`HX~|Jw+$cQTr|M<2vrThPS!K-WK9LleIWEwA39
ziEBd7`(lOOLj`lcGPIvAh$ilC2XT)Inz%4@UeXFpya(DZ3q=!mgU<J5poxEjwr?BI
z#G|0=Tb84VcS858ZblPNfUe6ui6;Kc1LFRtXyQrGb-5qW#J58CS@c2ce^~e^K+g|Z
zk0#y&op;!cCjR6(B)-m~iEo1Lr+$GZ?g$-sVus#-4zu@lGsOLpXySp;aehZM@zARf
z^#N$&iFpw51gJQO2Q3Q01$rh_9A<Afv^`LTCcXx`uc{qQd@uAq<tb?5*P!zY3(>^?
zG=Z&UScfL=3vK7`MiY;Qj+2}~6aNTZSAP>tTp4<<*E2Nn<<NfmXEgCJ=(rGr1Sn(}
z7+~Qr3tEr!qKWI~LEJBeCLRpUkLqaR0?_uJ1)6vXbU%VCnz&&kB>e=TiF?aI?CnDn
zUosP-egT@e5OkbsGn#l3bpC56n)s7T5dZH-6YqzfJ8=|Eob4Y({b@9DqjHFQE~1Ig
zgw7XVM-z{Uhp4}cCf*30mwb#S?g`z$`4Uas3OY{v9!=Z^dfqEDw0{hXUs$-Yqlv%Q
zfcQ%hO&q3P6-~Uk2of)LXyP#Su4v*npy#Nhpo!N*%g<~yacAhd-wrhKX~!Y%>_-!y
z2fZg{1Dd!ubUpTVH1R_MknyD(XyU@q{khN4#G9bw7_ZU98)YEoa7#hl1q)|CXuT<g
zChi8^muH72UU3eR9um>SVd*d(O<WRs-(N18cmniZjAAtLCD47Wm1yEyq3x)8H1Qbd
z`KqmG;&#ySpKdhqXVCGViD=@lq3aT-qls^aj?2wO6TfmA5{|3T#NR^K;p{{cp9Ed!
za~w_lJ#<~xRW$JmX#RbSCe8?rua9WrS4|-C@*hoH20H)C3*F}pi}zK~{UFk4;!mOV
zxF(vo1$4igIhwd0bl%VvO&k^uzG&jH&~um*(8Q-e*H5OPiT{JPldI6gb)fCfPBifg
z&~+Wt(Zuzj_hc_c6EA}9o7jRT4l{obn)v;Bkn-d#n)n>(zNb5A;+4?(@mFZ#Kej;9
z&kr<lM(F%98+3ji7GJP))kV?7VfM<RiRXkv%-2H`kB81vo1uv_LDv~NqKQw3o+s>y
zCO&5!Bpjm9#F?PyswJU|L;YEfCjPDs;?8<BaVKcIcM6&~E0jM6O2fkEqy{AYZ$J}=
zl~+5^#7{%_O<Y71_kfn$H_^nsq2s!r(8Ob3LEQffO?(z~-LjA@L>}f&MreCO3Qat_
z65@U%H1S60`6pIr;{ApYbHmZZ<)H1?cr@{w(0wK4XyO~7>xk;n#M_|#$LVO|EYN=3
zd^GVx(00WGG;wC={LTwBafKTY_y0i?7lyXCS)k`m!NRRO8xlSeXyP`|c}4{^aVhAy
zs|lL86Lfux4Vw65=>C@gH1SmE{{09vaW7~)umDY54!WPE0!`d+3B<n>(8NDM?|qzs
zCf)~~XW4)z&IhgUcA$y-&xYj3i)iAuRgiGIi6*{sJ4E~=n)p)adHX-n#I2$CMG8Xa
zEn)Gp7rNh85>1>5dcV05nz&0YBpj^J#6LjK+X+S!zYHxu>l7gRVD@H0%b!JP;!e<g
z94pYobD-zwZa@>C0bL(*1Wh~@IzM#^O*|aBKKTNgcq?>Y^EEW_1ZaQl9-6o$biMH>
zH1VK0ka+olCSF?xiQj){;%}kjkSvO*;WH7so`Dxl{0VgaMFvgW8@lgR3r&0%^uBcq
zH1TE7@jf>+@jU4HHX&%@PP!2HC!vX-g^sTlpoud;=P&Bf#Fe4<m^7n_OF;L}&PEf5
z`FB2=xGwZOpABf@i=gvI2hhY9K-d4ALleIPy|3#Ins_919r!CW@kh{l=LeejPiVZb
zDWS$AOC2OVh@gqzh2Ep5geDHV_s#%K`~mb{H#;=(OVD#QebB@oL)TwLp^0<JLgFz4
zO*{zNjw(YF4|xl5e+!!UV`#s15}G(Pc{40P6W;;7PiGyP_+#k2%pNrHGU&Y0DKzmZ
z&~eloXyTKh`w^a@iRVH0<$XmHKgR;`7YlSg1XeD=(hm=sct8~-+~m>3J)rTTj3&Mu
z+K;eA6Ni<1wrJw9&~dzQH1Unlay$u59A-`yn)o-Uzv|J%lb9g>ZATMlgr3W{6ipn~
zE?SEwUIN`WbQVn<)-Jk=CSDJnfB%Xm4r>?vMH9aSb*B<^T@Nf?VC@_&H1TQPko@L_
zCJt*y1)+&A6o>Sqi_pYj?V>6)@jdS$=I=%mhqa3iqlvG8o}YFfO&r!PdX6Uk0=lk)
z8G273%)hX95jUE+EcE<dbu@8UyGS2RTyiTU-o4SpVeN`wH1T_DAn80CO&r#)C`J>P
zg0?HV(ZpfxqRD9Da?tayHlvBd+C{MY5@F%c0lnYw4w`ycyY2~^cnP#!{Rd4P)~;iL
zj;F%Re*vAxmq8PUwTo2H#D7B1zqLaXp9DQ;%oj~O3A&DbGMe}`XnS}un)nOoxusjs
z#FaH6>F_9;I1jX*x`rlh3+-P&LlZv<-9PdUO<W&(kAoR>9|kOZgrp$p!46IQ4|F|P
z5SsW>M@V{$LKD9TJ#R1%O}tVNVtyH#cpvnBfi5)hZL1*WPeK!y>x77}MiZZ+3CZu9
z(ZnBYhN!=WCjJ__Ui}`L_#SAwWrU7j!otTFx-Oa%P23o&Uky!sH*}qe9-4U8AxJp*
zpow=t&(VrP6Tj&UNe>xl;-{eP&oVS|rneCFEokDr&~<=|(ZtK475N4<@dRi)d@q_f
zCv+dvX*BV*&~f9NXyVe)^{&s+#Mz<a)nC!XL!j+FW@tWug+DX&{7*qN@t5Zz;VF+M
zUJRYb*F_UQ4n3FI8ciHFZsUa}4)bpin)qetd99Pt#A9|q+_M}_{2FwgVm+GpS?D~%
z6*TeR(DhVb(ZqG3=k1F@^9?L~)<MP1(ZnU8;(=)5OwfI{k!a%l&~boE+K_YvGyf*^
z{IQ!j#J}MX|BFLhN(a^ac<4GJQ#A2VUx+#%H1TiHepv>ZxEFN(u>(!~C3N3YKMwKb
zIK<cC5I=?{-VHs6=Nu04XE?;);Sgtoo@WdTe^%(aWnLWOsyM`TaEQC0iSLHq2jPQ5
zJOzh%4i51aH1VU*{{93s@dD`i^>fg~HH{$U`ARf#7w9<&$I--pLeB|&jwW6YUAOZE
zDh^6bzaUitIHUfBio?RW?*v$wK|v3s5;2dd0zDr|7b*^tg>D@IYcPk3!^}yB?l*CP
zii6aLL%al5ZwhT+z|<Q-&+~Ld6VHO)Z|jRDeipipItWcX1-ecn4o%z%y51=nP5i-j
zuyYtn(ZnsF;~3Rw;?tn#V>F_Pmpp|8YCD>^3v@qfFPivF=zT_$(ZnrxLEJMFO?)-9
zeYF5hTmic8V-1@49CwI0`_RO1LC;Y+f+l_)y58~>ns_$!UWN;3;#;8nYfu^%k3P`$
zz#TO4Sy_<qd4wi@13G^70!@4$^uCPuXyPBB`{TZ&iLZv9EAk&roCms&ogKO#0_M&h
z=y)JMnz$YG;2Uu?aa-uPx-y#hsWec^W?(Qy6K~Oi_}3aud>?clpA(w65_Es4ADXx+
zbiTV9O?)TxJoyeZ@n_I;0H&ddXF=yvR-%cgLeIBZk0u@q9Z%SbCawcrU$+}goC&&)
z`XHM4%N3CDxq>Es3%VZcIhwdWbRGT|G;ufRdI?5ozXukN8=&JVd}!haVCP_<iMK%8
zdunLn+|ctPjL^iFLHjRuXyUa&5P$igiCaO}`$nOOt3v0wGSI{?LHj3VXyT&Kb2D1d
z#9v*7<m*Xj;<nIz2Mf@|ze4wYtV0urxqlm)_zmc~$CGH{7oq3xokbUio-?m%1PKpV
zym&&_&#*z)DZs?LEg<R?afqv;i5Ef77qUYWhneGsCN2hDmm7^HehPXHE$rSxn0uD{
zL)_DdrXDsf)QKkk4!Xa7C7L*FTxcVjI0JNl+(k5T*tpP5H1WC6a^@eJIBXn-4Z3~`
z=Kgl*Is_#&ao9MF7Ml1?=(w31nmBA6#t%*09qNuOG;!ECOc9#6AoSenJ~Z*fxsY@_
z4Nbh@IwbtJpozo!?|ab1`7I#kut4``!@_|Vy8hDzO*}FMQVzGHiEBa6X`F~AE~E`<
zq%1%ehwh_XhbDd=x_)~<ns^8FT$EF2;=<5%HP_I@7cYbO>k*nbgA7Fc8=Ckw=s9xi
z(Dml9a1ev;gAha$PlK*2mO&HGgYIY1L=)ev00}o!G;w~|crR2O6nh|**P!cl1JJ}@
zLdA2S;xKm}g^o`aK*eF^K)VqP?ND);`d!d{UXzi;K~vPQHHg#E#37-^z%U0%9CXxU
zGIU;e1(G<(9FQDH&l)sw=r9JuMyNQ<ozUuz;SiEI%q<{u&LD|{!Uwv%h2bueII{Y`
zP;r=lZ$R&*WrMcAVB%At=gf<siTgq4Pi3IuAa{cFfZPJYu=}+@Vj%y*+;0t44-<zD
z|1-Ei#bM^a-0FuzJPRrgGY7i7lpzmI9J*|Wp%^L-Gaq`a8bb@3IP^GkhDA_ukolmv
z>c0%~6$8U6s5r<R=uvlIiK9?)kb01Rq04g^PNIoJo97JYpyDudVD9-06$hCEvNr@e
zZo>er$6(?&V?eRYz`%<p9t&*`OQDH-LC;CHMiYmb?|~)`Gd~nf9A<tJnmEk-W;Ah_
z`4iB@Vdl?86Nj0<3QZhl{vkB+f6)Eo_t3;)_P$0FhuQlBO&n$~t0gE#5dBcDzYxAG
znmFv9Vl^~zC+Io(c4*=-_3mimF!k|h;xK<zqlv@()qy4s^Vd`~ahSgrp^3x%wF^xg
z=FY=t;xKpKMiYmre}X0sQ~w7|9Of?xD@eG)(lg9os%YXce;J{P!~A8BCJysgIGQ-j
zoe5~-Fn3m<iNn-4qKU)Q&qNc4`D-hhILu#%(8OW>I*%p}^VcJ&I4G2$R~&)MnV(Q`
zSh&I5$z%;uiAc9FcZx#AL9!roAgv7s26-If7Ep1J`Ji$PdK?9V4VpM~n4BRHNgPyO
z!RnDzG;vt?G@^;a!lw^S92P#a(Zpflvkoc_@)xYk1_jVjs5r>|Aosw+=Ny_iEPNh9
z#bM^a!sj&(aTe&jE699M_~e5$GB7Z3pov45^DxLFiG$n&3m-!?aaj2HqKU)8Ckjm*
z7Cz}{;;`_6%@2dz39=U!4jpLfVd1a|O&n(Lel&5Iy=TzGVfKDQ6Nj0@4BdYNa}UfM
z0W@)#IaX-mFmv3|#9`)ypozoGDL@m4g?|g0xQP;^KJ7&l&+~yq@H8}Wn0pqXiNoBp
z4ow{9o|9<eF!wyfA^sIj9Olk{XyPz;vP1Vj!NM8lPGK~0m^<as#9{8VLKBC%(+^D?
z=ALjgahQ7&(8OWx$w3o`xu*h69Oj<MXyP#UtV0uj0v-Q3h9(Yk=Xo@7m^*KviNoCa
z1Wg>~&JSqfFn9hz6Q2*g*IV2kl8#{U0&~9+nmEk;erVz__3dclfzWf<rl5(3LB-dg
ziPu33xUFd7+R$*jgeDFvH*TYe!^Sn9poxEmj)#6k6X%1jm*$6#qr<}CF0|hvfhMj3
z9p_O*6NlNWg(eQO*Bnh8W^XW>I4nG~afr8}iHkzd^;&@@4og=X(ZpftY8RR~EL|N#
z6Nja%OK9S-baf9+9G0$rqKU)&CE|#h-eBp<08JdGJ^_b#ADTGKzthpgVg6l!CJyuO
z8Z>d3e|MmX!~A;$O&sQ57U;eTSo(pvUl)hC1Dg0F8Av&wh9(X(ryqy-Tr_cRXai^;
znmEjy=QzZ_qKWrF&+9gang{b2EML2ziNo@B44ODBU#Fsp!}4_}nmEjzYjKF5Kod`c
z?w@&uCJsvvpV7o&>46n`ZVk*|u=F5=CJsvv@@V3)^pJ`s4s(Ak4)Lit#Mj~wzl|oo
z7P=nb6`DBAUSVj%7?jJPTckkEPX;ZhILyCiq4%L1qlv@Ju|^UHwI`Q?3}j$nutyVz
zF2`VSK@tbG>$0Ked-x-XgUo?0D_{sl6SsvVe})JoagaHF(0RaQByo^Auc7MG(Zr$G
z5i^t`iG$4Pgsv~?fQo~>0}3BuaOf~FOu`|)4k```H;}!7(0XbUnz%1id^ehS4^(_V
zns^sf`~*}S-949Zh`)!5!`!nOYR+dg@%2#gKWO6bpyCYB{X;Nw-ay5<q2e(2!1^$v
zIK&O1;xKcBp#x;5XySrUaeJsZ%zO=K_<KUdLFRytoD%>s7#J8Lk;FmaZv{0c7ERm?
zDxQWWUIi7;LK828iWj4aZ-I)Jqls^TiZ?*T(cRw#6$d#R+5OXz#6j+V2Q_Cln)oZI
z_!2a64e0)?6=>orQ1Oju;z>~Pt!UzLQ1N|GahUs|+h`b0;1GWb6$kkX<o;Pub6%o}
z&wz@5LKEK)75|1Nz85O~A5HuTRGb;Q4i0ATBd9nBR2=4hP*{VKkUE+;bQ>{)Ar5gb
zs5s1gPBxG!3=Do~;_OiIa5Ql}sCYD*xDHf29V!lUC-fL{hC&?Ty-;zOdxD|nOhgk8
zgo@8X6R&`Z&qEV0gNm<!io@KK1Mx1yCLH4DpyDw1%!QhB2~B)9RQxuY_#vqHeKhd{
zQ1O>gahQ9c#~Uzw#v#rRJ%0k`o|jN_gwe#GLd9j!#Ff|~9#%jTSAdFZLdDVDV~j)G
zA1V%Wk2}<yU^H=8sCW#Tcn(xN0Zlv$DxL)uhq(uO%mYIS4)F<4ahQ81Ld}_iCf*Mf
zp9d9(nGZdFgJA^@@uN_2nEBhF=A1+m-vSlC02POs4?X6P;VF_hbg3~oV%{T(gX(2i
zev$M9nSdBSgthCG(8OWwH$60QSo_TtO*{s=uEGyZ9A-`wnmEjyDl~Cedub95@!4qN
zDbR_u6=>qmpzD#gqKU)W+lSD^VeRdEXyS#xA>s8LO&sP<Cg{3aP&|U#MMlthRem&a
zm^p@M;xKbOafoN(5bwhwz7kCwcJAb9G;vtGUqKUxwdbFqiNoUYGnzOo9vPtfNMPXr
zYtL7piNpLm0f+bs9OC<+;-J`oZZQR?^Q%yCn7uIb?;?qV>e<K8eDn}a{3cZV8Im|C
z9&MoGJ0Fq6LFObu_pg0L6OVw3|3VT6nPUZAufhr)Uj(@mWX^r4dQLR)>rinas5s2O
zuy&mc4si>pILv%!=%l3$nz$oW+!akc11j!`CY}Zr4}yxLyC(*RcqvpI=AH>qb1Koq
z`=H`YXyV(T;%#W+TcG0oXyUh_;*-(DZ$iaqK*eG1hi=DYSdJzRYya#(5{F(T1x{}l
zq2eHaf#MgI-kPE7snNxkpou#}*N?456IX`r!`+1@E(hI5tOC8a2WI{T=y*aZnmEio
zm1yFyd_5ga999l2Kof_l--IR(D+l(YiNnf)Gic(la^NkRILw_c&~;KUf5F7#(8Q-e
z?-y=B6NkC;3Ys{~oV#e^uyqcv(ZqS7>qvP5Kq&-KKf=tBLKAm`-g9b>CJu8?H<~!i
zoGEDHF!wA%6MxSR=|CPv6Ni~|5l#FmbRYCbs5r<M&?A|^>6Qa}t{8ea3m}Pu$|Y`)
z0tN;K5j1f|sJJAOI4J$Y&Kp!k5(k;n301F&CSDH}*FzEqnZvXjG5}$PBn~o%8G6o-
z9h&%Ws5$;<;`vbZ!D!;iQ1J*Page?I(EXb!Na7%SnRvj##*l#~{taqQE|NINoKEO{
z&6P;vAalB*=G3Bzw?oC7ki<de9RCincRrFh$ei;~^^4KO4?@M)K*eG4t^hHHVH*zd
z%TRGpFoMj_gx<4x9ZftPD*g~E4l^IRT#n&2R2*ausO$`Y_80yjiG$3a05yjJy1o^p
z9wgoa73YMCqnj^`LtF<c4m0Nj)Eome@ncYNOQ<-y`OY}R<Dud(^WQ?vNk$WY4HeIY
zildufjzhd3Dh@MW2s&>v8BJUODn1`74l_Rr8ow)Xh#!NB!^}5_nsW+G+!QK)1u70R
zA9^hY!#$`t$Q)4oHbCR|J(4&m9^;_qd`1(Gf{On^6Q2PUX9xz_2q|wt=1hT#bE1h~
zgNpN_iJyati$TRfrh&>mSbs+Whqx_N9ON&My(avS0ChwYH-d_Lp@~OA#r@F4!=d8g
zXyOe}@n|&h8mM>zR2=4h=(2Q%dNlDR5N9%U;t*d16^Hq22h{v!XyV(T;_K1G??c5m
zqlw>!itmGp!`ulyMw;OSR2*b4D4lG8rjwgU;-GMrgr0MC7foCgD*g;jJQyne3QgP}
zD*hQwd?Hl*JDPYmRGc9M<Z=e^X%?V#(gh7qE*#?OP;rpIK<<ACHAfpw{619N1WlX`
zx<A(fO`HWP?uaI?2Nick6W4-@dqKrPz5ux&dh88DF`77Z8#+TR4)JMFahSidq2|v*
z6VHT-FGdre2o+zBCf*Mf-vkwhxf43=z_160_)Vxd%stzn=G;XS-vSkX4i$%)4_p8F
z5h@Nc2b2yUK+_>pC`cuuoVg1%hYd~qCRCgsO<Y_El2C-v#D$^aGHBw#P;mt`abKvo
zCR7~cDo{LLf*8+Wj6*yCDh~1&C><__niGO1z7Q%Niza>oDxQcYehey}g(m(UDxQZX
z{u(M?3>AmDA9{=v!&EeJ=yl!<^KpppfQrNXr30Nn+Jh#p1r<MvCLRbCKZz#p4;8-x
z6-RgHJsje{q2e(2ltIn;k0xFM73T;8nT#k;VBsKyLtGCk4l{o?)Epx;@tII@Yp6KL
z7En5YneU22JQgYrGyee8oJ2J7eNgcns5s1g=(azGG92Q4P;r>~Pod^aLKA-s6`zeJ
z&Mg8-==0IUIicb!pyKH6*@Q#<6jU7M9s{U3=g`FUpyJoj#G|0%x6#BSpyE%^#OtBr
zFVMtmq2eE*;^^-GjYC`nx_=Ai{v}XzB+$ecLB$o(#Lq#+Vf(;f=A40w>!GRt3>7y*
z6aNSmH;0PD-2WUBT?{@r#KUli7emEi?vW6M7*viXE(R5EKohrxinpMNTSLYBpyDuh
zzK0mkFawA9R;W14JxNe=cA|+VK*bNCiMK<=kD-aTLdDNO#bNFVg1YA$R2*b4sDB6R
zzjHwEF$1ZWhN=Zo@=$S@df2)G4K#6>IR;4Lpn72k)IBC>;;W$ImPq0t_rTT_xFCsx
z%!v~NxrTwk15G>tD(;IU4l)O}t{?(Q9AwTvsQMT*@o!M^EF^J|Ik0sFwNP<b_&|#j
zhISm{i=pD6a0A(!0^Mk_98Ej{D!u_td_Gis3!3;`sQ6x}IJ$d|;}CxW6^FU!7}T5>
zXyS*U;vdn(8KHxYU(v+>L)9}t?>U6I2ez(&3x~KGR2=3WHK_SoXyPhRaTBOG%zW7R
zvmI0%WDcl(wE!|q#o&h|4hnx?s5wDs;+|0PXf*L&sCYb@cqddm15NxmR6GYw{4i9!
z6e^DH{(7i5y8C;O#6j+7gibO{KokE9HGd|WxHVM$Tr_cWsQ5B8@lvSxDm3vzsQ6~6
zIL!U9bp?BIh~I*WgZu?@|5~Uy_t3;wL&cw?iC=<>zeW?k02Tj&CjK2N{sT??D^&b1
zR2=4hP+9?%C^AtX5lDLpRPMpn6{z75w}*<u{3QdO<a9<8mx7A>pou#|#RJg9?V;i^
zP;ro}K<<H!8>Hb7Z-R=$+>-`1rwvU!1uEW;Cf*GdpNuBn2^F6U6^FS8wyt0~4)McK
zahQ8HK+QRhCcX|TegRGVDpdRmn)qd?_&umN%ssGm1ut-jvq10DgSqDq)Eo{p@gGoe
zK{RnwP$V!gFo>dw8$-qApyKH6(ZC_@0u_h3Ckkqg2by>UR6Gz(ydEkZiY8tQ6_1CC
z!`uT~SCENAycH@AbI%f}Ih|<Yi=g6@q2e&}Ve1O!;t<~j6^EIB5^ByqH1Xq5@uN_2
znE9}E1-FpIp-~0Oz6?*0#6d>D@(W)K$OK6L8dQ(N=9R?J#9{MC%4p)S`6DYdaoD;7
zXEbq`IsRzkFmq<2iNoBp2u&O|U$YubJX;MiAF%~Z9A@u9G;x@{=g`Dq^Ix~o#Iu+o
z;q?bid}b>+m>CqI_gjME5fq-V_MRmU@dPw+*n0j<G;!Fv`XV%O*t+_9G;!Fv`q^mW
zF!yZ6A$|=_{0#Iwice_bFmrh0AmIV??;+^9Nj7NWu=Tp$XyPz)s&I(+K*d3}XhMP*
zOfH6s!|a8bzX?qoX8tZDaZo+`1C$9E7#Q}UiNAr0A4U=f#p5IBJl%ODagaI9&~+o1
z(Zp+^;?L2<uR+CMqluq^iho2B2iXe?|G!A$AbWkF=h-qs@3jVn14!HhD$a%^4l?H$
z^nODjByo`XHmG_rH1Q^=xHOVD$eb0>d3kjtagaHOpz5{J#P>kO4Uoh^=D1mbqmjV|
zNgQO3C}^;Rfq}sRO`I1h?usN1GRG9U4=@l(9Ar)>RDCF#cq>#q3P~Jfjtunvf;1#?
zkU6KJ>a)<q4?@L@q2jRg37fyGg^GjX1=NNLfVQvtki<ded&on=VG^3S3sihIn)nQ;
z_<S_+2~hDBXyX5&;%m^ve?!GLB8elra~G00$es33kL^PfH-(BHhl-<z!$ln8@1WwK
z@Bx{B0BX)BH1T~<@jp;;nEA$#U}Io|uCoA{19E=@G@Qke#6jl2gqkCbCjJ;Iu7W0R
z1HETf15MllDsBW7hq(uOT_J-F4)IW^ILMtK_f$d6i9{2xfQqL=#bM?{kN0NC$06PW
z6^EHWA8O77H1WAm@tII@bn_SE5Z?n8hnar_YR&;P@k3DY3s7-%^Kao0{{t0=ng0@M
z4nrcy1W5Y?6mHL<;#^R1kSwTPfSq3<0u=|D14<7Ypy@#sNgQO3C}?pd0|SF5nz$fT
z+z3rP6e@0pChiRtw?-02w$}wJ4s&NGG~N0^#bNGz0Ci_Hk~qknC!prXqlq7Zif5pS
zvnfL?$UzhT2UTAR6-ReZJyaasJv~U`Aorv}&7XiKo&*)2i6*`XDn1uYd>&MM8JhS5
zsQ4;0@f%R_^-yt``&UA|%Wx7+yd0!}fq~&3nmBBJ?FCdE=3fD5WBDhNILN<t&;gpi
zXyP_daW?4r79ev#>XV`3TxjBnP;p^2@qVbdIGT7bR9pcn4)P8tox|L(1r-O`3rcS=
z_nRY$gWR(PYK}FU_$H{h3!3;%sJI83_;sjwAeuO<DkK6z(Zrdd;t5c3nERo}!7^mw
z5O0TygZu?@zZTS-ZZvTXsQ45#aet`z3^Z|HsQ5xO@e-)`QZ(@*sQ5ZG@tIKZO=#lN
zq2jxt;^_W8ibMPnR2=5teNc0rp^5K-iob`7qnrN|hqw^*Tq~IQkD=y>p@~0)imO4z
z(akr&A?^zmhndd-Jr^_(O`HuX9t9OgH$Mf3cr8>MX1*@eoJKTpZK(J}s5rX$vvG)T
zfr`V-4}zMr15G>tDt-`6yc{Zi6ivJoDt-ehj_#gEIK+QL#bNH512yMAn)ocJI3M&r
zG<5Toq2e%e4nozdqlxc_iW@-1(ao{KAsz%3hnfEzYEBrM_*1BOCR7~V{9+v9-B59u
z`8=S*Q5YB)`q9L>pyG?5;xO}}#~w4R!6AMUDh@N>5Ngg@G;w{X_%$@~2&niiH1QCq
z_+vEj2~hFpXyScP@efdOboc+lAubHP-wEdatx$8s(Zn}H#TC%R??A;>(8O;*#dXod
zMW7Q2hG^nKP;oP;IJ*12q2e%iT0+(PqlueC#Ur5N=;kEh5U+-c!_1F|np2M^9t#!k
zKof6+iua(2H$laxqKWT=iqAw7-vbq&2Ng$m|7NH-%$<*+>bIkbKZJ_!fr`V-c><|s
z8E&JAAApK~MiYmne?jPZv@mm^*GDr*;}Exiio@K=18Q_IFfiDliE}~4UD3o1q2ius
z;`&hWAT;qXsCXEfcnDNH9!<OkDxQocUIi7;fr_L1w+x5)WT-gIzYC$}Oh*%+4;5bk
z6-PIJ6%O&kP;r>~$D!sNM-x8^6~7J@M>qc=4)K3bahUmUq2@3_?<IhVzlMr)L&ed}
z7sVm22Nj2zBcugMa7Jk20#I=$s5rX$J~+fvq2e&}&7tOGqKTVA#f#9yW1!+?XyQ>&
z@lL2Xx_c($5MKiohq<Q_YR(2U@p`EEeyBLQ`B$LgFmskc)!#r9Ujh|>2o*;+=QR#-
zX6U)dF!Rqq&0$9qKLr(+f{LS?uYyC|1}Y9S|0C2K2Q=~bQ1M`>ILv(L^#TmBIK-=<
z;xO}J=k(U0iHktb?`=mDw}y&$qlsHW#iyW&Cql(%pozyr#TP=w(cQlqhxiewIL!TR
zP;*Y8iMK$-FQSRBhKgTB6JH4xzlSD%5i0%&P5eAm{5ez{-Ti-{;xKo9gQ{o91gS)f
zt9*fqb3(;IvY;XZ7LUR>#C4$JF!N<}AmxJrnz$5H+!9UP5h`wrCT<TEcS93Thl+cl
ziKjxv{h{LM?oWY=!`#^eRiA+--USuUg^I(>fnEd4(1Rupy{>^_DVjJe+zz9OL$5Vs
zIEzF48B`qR&aF`Qyh0P-3>E*3CjJO2{vA#H0aTnJ3*;k2yt6|$)Ulw6vqHr=q2eH2
zp!5K9zZ{x4^g1&J4IJW*P;r>QbfD(DqKRuk#r@F4Bcb9!XyV~e@n|&hI;eO&ns^OV
zJOe5Y^B2thML5K}q2e(2FNT`ak0!nlDn0{E`~p;b4x0EmsQ6Me@vl(vm1yFhq2lYH
z;xP9^ua#lA1r-Om6Ev>@n-`PI2C0O^J4k#Z^xjEzG;!E`nE{$OY`vKcnmBy@7@9b2
z{;>p29A<tkns^}ep88HSaoGIV5;Sp`IoHs{Ve`fJ(ZpfuU!aM@=7qnaiNofFm2yzS
z4Q7rN4)Guy;#oMvThYWlr$EZj)o9`{d*7mo!~FXVO&m5q{vS;oHb2e*JpdDyPGI36
ziY5*Z2Q+cm{J1`vIBb4A08Jb=KVFI^4)a$p4)HB$;;{Mgy=daF`SD|D;;{Mg%V^@T
z^!Xl59OfSOJnZqVg(eP5pKfU4Fmn>o#1FJX)+bCr6Nlx~`Do%WbI#!qe~BgzJ4cQc
zdhjVMeqrWFpoxFvgt*5BDh~2BbczL>5QCxO=;lNtiG#*z)u0RA;?cw<pyDY=;-K=!
zM+9UO1499lILMqcQ1vBf;s>DOl}O^CaqkPza{%g)#6jk>L;J&BNa7&#L-oPlV(3E?
z4}^+OMiK{^13OP(K9V@doPMbK#c1N)Q1KN|agZ-T;R#z0wihZ63s2a-(X(jcuzlh;
zk;Fmvo`jlz7ft*qRQwrK9A+<U-PZ>k;=BbQm5_P?WIm$-Bzy$X#Q#Ihmx79ebb<T@
zGhYRVxC2xi<X@2aYEbiC(8N`s;=WLEbo0Y;i04DaVdi^7%_&9`_k@bqLB(O_!`5YW
z;1FK`6^EH$05xX`ns^>md@Y*zG^qGSH1R1=@m)}HboU&=A$|uc4s*|Ls5uYN#CJl)
zU!sXWg^IsL6Mqa9|Ar>cWe7<RztF@vpyJHX`$o{+&x=D`4Jr<EzdqC)Ei`dmsJJnj
zcqCNZ98EkND(-+LUI!I-K@+cmihDxEVeW@6^I?d?A)bLlycH@A^Vedi`JHIu3!&nZ
z(8Nzb#iyZ(AA^c7fQrN13B4wfVHFPX<4|#!d)`9LIgKX%8Y+GTO<c$b67M(A#08+@
z_n_i1_du^fWB83G4&A=Mz*+=S30Xf3DmP%_N>Fi_JI$fytD%XTLd6ZB;vmyN=0K;-
z8LXh<Aag+V0t56s7H=eRQ27%FHOC)KJPIlv0To9#KM99;HB=mAFUb69P;=_h#HT>T
zJD}p|=1;;Qz78r5Gk-VKoK0xrJE7uxpyKG}AHyMj4=N5b{{hsTM`+^rpyKbK;xO~g
zAjyQ`2M%%3VvtHi{lW@exFd-s&I}b-hKhr9f#MgsOpHMnhqxD19Oiy4s5yRU;u=u#
z2&g#BeCRP$3`tONkU60AV*pJ*#Yp0y_zi@bQ;sI?3l(ob6YqwKx1fo)L&ba1#E(M7
zC!&cTgo@9Cio@LR3=RJ!IK&S^#X<f8x&JTJoTF&szoFvi(8QIX_sv~G6IXzW-$oO6
zhl<}v6L*D*KY@zF-0ux_|6ermnNV@|5|Bznxd9VbfQrNXl>;?j1x-8)Dz1wrJ`pNz
zh$h|-6}N$kgKP(-Lzp|=aEQl4#bNH*1~n%cO?(SfJO@quK2*E_P5dTQyb>yo?w)2G
z;`5>6F!$)2LIQL#nz$}hd<~j-2vmFnns^XYd>2$4<{p2D@eD_Bh(Cae!`xE|HRlPM
zcsW%39aJ1<ekj!ZA2`HCOF=3T<;*;&Ig)7NbD-inNaCP&KJ0uaQ#5hd`A$w~;;{3b
zrlN_%`dMpnh;Ks^hn>T77)@MhI>f^l(8OPaLi%g3q2eH4LzgguH87QdL?Gb+@)yiK
zTu9=ea^Ng99Qe@04?@L-k;Fmfz}zX1Bn~ns3t9mvqlpJW#Wj$`LFT~D3o=0x2boi4
z4t73+1)6vPRNNCy{3}%47ft*<R6Gbt9Aq!-yr4KFage?7&;xOj(8L{~;^|1@U~_aK
z;a`j-4l-v6^j^PmH1SDL@fsv?kU8p?A@S6KBn~ns8(QJ@poynK#U~<(gX*aQX#aN^
zk~qkmqfqs$(8RYw#n&T=gWLl<2WdBwILMqzYe>B8M-wlFiXVZBgM0%@heD9xVYmqu
z2jzE=`I6}nbDkoJgUsIvHRmOo_<E@LC#X2gd<m%ee{hIPLKpsl>;;)`1R@w17-Z4J
zHK5{ZXyS{Z;#z3p3!&o1XyPZJ;^t`L$Dra4P;r?1<)H5O!Xcgx6^FV1Gt``HH1W4k
z@e(v~J7|NZ0!`coD&B}Do(vUlMH5eiig!W9VeW@syT`B*P23dfuiZGruRz6N{_297
ze*;at11kOyO?*96{3)9FTB!I3s5s1>!BF@7!XYkP0a6JmCqY4Z3u=xyn)nr{xB{BE
z9w_rMFfgc~iEBW`b<xCIpyGyT;&o7QE2ucgRiJzn33a~<4)H{&I4nGGK+Q=-6Tbo#
z&qEUzhu)uFgeEQw6|Y7UkARBTqlt$=#ap1_F!w{Z0WoYt6HkTu>i`b%n^19>zotXY
zzl$b56)OG=O?(ej{1uw`E~xl7s5s1>1(0HifuRy40%>Q0!XG9s3l)dC=P}eAMKtmI
zP;o6Zaajk51$t=Wl2CDTs5r=WWP2TPh{r+2VeScqnv;Yk9t;)FMiZ}sisz$=S3t$<
zpyDw1R6v~1(1AmIAygdZp7~I7mZFKzg^I636F&kK--IT92r7OEDh_iG^teriGf;7m
zy`Ut%09p^;MG^<)>(@|o9-@gqhl;;K6ITaSRtyXb@6f~*q2k}s#A~7AztP0Yq2esi
zdzfMF-vbR#J{;oOP;rpIK<+;eHAf#!{47-50!{oIRNMwl{1a5%6;0gS3F076G;w37
zxF1v;=Kiw~<qWlG;?V1$8QO7(FMx`}{8a`ue+im+2~>P7n)qy}_(nAGnNaaPP;r<$
zp~r|Z9K#|07%C2P&k?9O&(Xy9LB&6yiSt7{-e1tfd7<Ke(Zo%l;*8ZG7b5B%Bd9nR
zR2(D=DhHt3@EJsKh#Nx1VeXHGnq!J49tjn<Lld706?Z}tp9~fEMibu!757II-vJd5
zfr`W24;>C-s74cqR>usjIK<~c#bN$>2sM8Zn)rRF_-Zt9HWx?&U5_Tt0u|o{6^FTV
z8HmBaz;FbI_(P~T%sskLbDpA!YeU7~p@|1U#Xq5m2SCMtqluS8#s8y;mqNukY9I~<
zk)U+42E<@sU=YF~t`8N5xqlwi9Ah-`IZ$yMH1WewaR)T<gHUl#H1QWuabGm?XHfAV
zs5r>kAom{yF&G#aD$&GGLB*SKh|htF!~De$-GH|MO`I1hz7kE`1S-B3P2317z5^-_
zat6qqFF*_i28Kg8#P37JVeW~Bn)4V<JQ6DY22H#LD*gdYybdb<6HWX&RQxZR_*JMl
zTP?)FAQI&McOV7>1A_n#ab2i5%>DnM<`|-h|AC5Ip^2-yLGqm)nz$lV+#O9k6)NtH
zCY}rx4}gk;oDFh6^qP8xS~PJsXnV39hxh`hILu!?Q1h3diFZN8*P@AUgo<xO6JHM%
z-vbqgxsw&dU|?W4hC}=@R2=4>8&GqeqlsUGihn>8XLN^z^A|Mn-%#~`(Zs`{>KW@G
z4ujbn2o>joii2c9;mi$UfX<P|A#Mm2hnceyYK|$I_;RSY9h&$BsJIiF_!+3UH=4Mh
z2gJYrXyUw3@ersu$k`zGOMn;*3=GX^;?V2S7<zGtFN2E1{1pH-e-)azA5?rZns_Nx
zd^?(WF;x5zR2<|ykUOE*a50?0A^sF94s*{es5vju#AiUoKcR{5hl+ng6W<FJ|BojA
z1S-y44{{-*eewt@&I1(($%5Rk2VyWVFo@w0H-?JC+|TU^iAQrZaZaeX1Dd!2RNMtk
zTn{SlizXfl6%Rxc4~B||LB&DN2Du-4O$0+NnmF{DJcf20;tQbSFn`rR&0m5hUIi6j
zizdDhD!vg-d_GisFH{`nPU!J|49B73AbUam9RX;6=LV8EsK0OuYR(-r@ncZ&r)c65
zUXXZsi6$-t75{`Lo&^>Eh9;f@75|SWz7s0W+yL?sB3*5Uit|9lL9(EDf%#Vqhqy6R
z925>9|FT0TX3WvVS)t;#P;r>~&|@AL{E)<<M<IX%A{I#;<Q{0Zi6I>-4zd>%{tnRa
zuRsz9xknFbZw;Eb7F4_yDh_iG%=~^F;wzxyAbUaPr$NnGgC?E=72gUKM>l^z4)NPi
zahUntP;>61iFZQ9UqZ!U=0lrx44-j`b2oxiBI11m)Es^^@pVvfX{b0z7byH|q4m2e
z4sj=_IL!Umq2{=uiC>0_`=f~q_<*CGAs9`Z4=Nr56-ReZ8V>O$s5s0$rciU*(8P_Q
z;{9miQBd*8XyOr2@wrfOn0p$b;j<iv_+h9x%sur`bB?2l*FwcFLd9X`w?NImjYIqg
zR2*jh5~w+U(8L!(#hIHxCL_k#VDak=6$hCE$`i18t3WjIg9jk`i_pYj>Ko9+eW2&&
ztV0tQgr?VXXyPiDAm-mj6W4@_Gd4ryVeW*@8*-tE!{!ae(Zpf%hQ?^(F!zV!5HCU#
zKYtMtF*DG_Vdkts6Njw_-ijs;TlaeqO&qrF_YRsk%$%oa;xK#Pp^3xH|BWUNGheL*
zH9TSKnf1}cVdhw)iNnkZLKBCbKNgK94l^emO&n%UJDNDmUpsM#Uq%zZWCQWfS2S^0
zxcx&Dhq;HV6`~K8u3+v_MH7d)Cme@(0-8ANo|-%~@gjCe`sqg#hnYVYO?*3af@c?+
zILu#%(Zpf?I*%p}^VcghahSa_ZK&Y@6IVqOhxyAGO<esh#9tw3;xKcP(8OQNfY{fE
zCJs}-42Sr7G;!Gc_#QNISb1^{O&nI9d_oh4+4~z!9A*v&bf6WMPGII3qKU)ycUYl`
z!_0R^6Nl~Z@JADe?e91M6$gbDbc-^$;=B$Ohq(u~j{O;$ILzL6NaCRO%w=f3@Ci-)
zI8^*Qk~pYdfStp}+yQb4qFoW^3w90zJDPX|R9qTOd?Qp`9!-2XR9qEF9AqzSoxdTH
zILQ6#eh_<2(ZrRZ;#NrFAah{nu(=_LgUm^Us`o+@kA;f+BZ-5|ft|w^jU)~-XD(EI
zJev4)sCWvJILI8>Icx<;;vjQAK-HI^iNAn~S0agn%z>T5)`}z!GA9MPFsKtvJOL`+
zha?U%2X+qIEF^J|Im@8x=b?$ufr>AOii1)GD1Cz3j-Z&?2o(pVPf)u(0eTMbAtZ5-
z`N{zx)eH>B(8T4T;^)!Ci=pC|(ZsW%;&;%*Z$ZT$pow3Dia$jXM|S5sByo^CrJx6W
zenJx$fQtWyilc`EYbQtq((XbIA0?<bD11QX&xV?#h9*7}DsBK32bl&k2fA#K!3ru4
zG6&@T3D9u%MiK{^e*|idKbrVHsCWdLxH$Ac_82sAVW@Z-R2=3W=<p;%0S@s_s5r=-
zAoqkq&FMuG4~B}*go?w=hn>T=7>D=)s5s30DyTU}(8MdC;%A}a=;mL?A^rg>4l{o~
z)SNG9;&Y+mEL|Xz5%CUlKOYWp1E@I6{3B3vOwhy+LB;K$;vic<=>c{Qn+H@JWDY1j
z9Dt^WNF;Gk_<w+!6N@JP1}dJ0CT<W6$){Op;%ZRwd?ayXdn=&gFn7YvVQYel!`%4+
z>dt;7agaL~L(QLzCO#i3J_k+wAyj+;n)pqq_)4fax_dT5#nIh!07)F=9>)+!I2=I}
zw}pzIMH8=uieE$%uY`)<LKEK&6~Bijz8Nb17%C2PKkOW~zi8sH`97g;kV-^4gq>q1
z0~Lq)R{^@9Ul&On<X=hX0#HLVadD`)6`HsmRNM|t+y*M{jwYT3757FH&wz@DK*d46
z0Ht%7`{SVE=<d%(5(l}zA8JlMns_f%yaG*p3sk%YO?(qnycJFS0aUybP5d5Id<s+?
z=6={YZ1Zr4?}mzl`~`A9YZxTG?MD-5hKip+6W4-@pFtDXfQny56ZeOT-$WDlg^E8y
z6EA^^KSL8Qf{MR~ilh7YCk}D39*{~zdvYe!94R#M=}>WHs5nR$C_TW!Qx}K08&n(?
zp8KHYc%g~!fr>{##nH`A!6DuV6^EJs7-~){n)pMgcpp?8-TWCi#5Y34Vdis$L(;=m
zG;ubl_)(}hy7}jEh`)e}!_3!(n)3!tTpKF>6-_({D*h8qJOC=r(+hG5qWpoymlzIl
zeW*ChJ>^hyjM2nPq2f+ZagZ&@=^-2{4l`#CRDCp>_$;V+3RE23oID)jZBTKT`G=t9
zbfJkKfQrwBildvq9EbRRs5s30=TLJFqlrI-ieH0@!_0@BL-hcM_+O|v%zT~*NV;O|
z1DSxxk6ci3E;Mmts5l>*xIR=|98EkMDlUyCo(UCKfr^7{2gM`I{dzdW-J#+z_fLSD
z<BcZX2Ne%N6W<OMk3bXO3>8mA6MqjCPel`d3l-0Tile)~9x4uVr${6uoSV_ag`na+
zP;qo~rr{7@4;6=*Zv{1HGn%*sRD2Jbcp_B%0GfC#RQx2G_)MtySv2wKQ1MGpadh`T
zhl<18xeu!THJbPysQ3q{ILsW_Ic)s>AQ41)0y~FI9ZejTeq7PSVdt><;}Fk*io@Lb
z9O|9|H1VfU@k%st9_U50wP@m8Q1Lc2aYLwh7n-;}RD3d;csNviI+}PWRD1zc9282R
zd<66FDjed+q2e(A)<DfUjV4|N6~6)%M>qc-4)O0$ahUmwpyvEW6JG!o=bivE84<rQ
z_lx2XH-d`8%s&A&#|%yU7*yOIDh{#*Iea{Eh$lhCVdlSunv;em{u(M?1{Fs)zX6B%
zOsF`_e4%Ja`7jqvTmUM*3{Bh|D!vL$+!QLl7b=eKp5r*gA3()n?umh#^8`&i3M&2?
zDvoYG$3&0_q8@34s^>uyuZN0@Ld8M4kmE%jhqyUZ9OlmDP;;!&#Fs+F{h;FL=11TV
zFMx`}%s&G)rvy#>6jZz&Dh@Lrb`I4<9OCPs;xO|+Le1HPCjK5Oz8g(kEC!NJ_M?f5
zK*dj>iQ7QM&!CB0LB+2^#nIh=ABXr4s5s31iBNO?pozyr#aSnTOh%-KHmEo!ns^IT
zTnJ5k4OCnVO?(wpTpB74vIUfWVBv276^FU=B2>Kzn)rFBxGhv1-5hru;t5c3nEBtK
z=A@vBe}#(YqKV5uFAgt66PJRDSD}eJLB;FP#2ujG%}{Z4_s@We!`zt;RX+z!JQXUw
z5GoEc2X+qI0W@*gIczu4#9`t89Zei|jv3=*kjaR09wsgY6^FTV0@OWnXyScPadkBD
zy-;y&H1XX~aT7H0M^JGKH1P*eaa*W3$hDw!1#@Q*nmFtnvltxWrBHF0zu4m-`L_~H
zoE0kGgeGnR6>mcmH-d`yqlrgC#V4bQheO5ZK*eGHg1LVg4)Og^ahUt-pynJ#6R&}a
zpFtB}4HdtDCcY9XeiKdn0#y7in)o@W_#>z|%>A%)*f^(vL?Go1XkG(0|D}c|4x2CQ
zf{KH5L66h~N6bQ~ILN;sb71N>pozoG-+?3!8n^ikb>|*5@y}54^JwBJ@nCBiE~AM@
zLB;Pv#bNH`gD7Ws4iyKv6EyDX0KHG)JCZoaJ-4Ce{6-VM2^D9V3NjfIZXopx2@nf7
z(8T{i)eEADt3uU_qKPX*#pR&lAX`A;40FE*R2<#?rbyx-_jp0gu|yO1fQmbziRVMb
z-O$8yq2m5%;!~jF!D!->pyF{*ahUs|*AOve;1F+tii7+Ga{o@KIUQ)?+o9qUq2lP~
z&&DCX11b(P{~pwwJ!s;0pyEfN;^^j|$07a#Dh@NBIT4Z`-k^yyLdE|;#bM?{uRUR4
zn+6hrl=Gl?hl$HW#bM@aLCsM{6W4%>8$!iFrh&|X9&gWJjYB*UO&nBqgM5&UL%ba-
z4s%Zc)ZT71aX+Z|6sS1NJuvg<;Sk>r6^EH$3N>dpns_l({5Vt`W<G4bPkcH^1d>ld
z<r1v?Q9u)it&8wM6Njx&2t^ZznG=U54qKm)g(ePLpRfo`9A?f%9OAdo#7$U1vBJRc
z9x4v<9V~7^GHlRwBA{>s`4?6W!~6#mhuJHOq#l&-mO;Z)5lws+R9p>79ArLhor4jQ
zILI8sB#>(u7|hVbwV~o(XyPqUaX&QiDyVn}k~qj-*gA&<Byo_vzo6<<(8Rw%#WRt_
zLFT~LIg}!agUm63UOZWeCT;)~uR{_CnFCwr(1j!pGN%Blz7I`23o1StNgQMjY@Ne=
zByo^AhoR~hqlxc^imyNt2blv~=dcAy9Au7p3M5{3potqp#rGnKgUo@gb2y144l<__
zs{SmRcs^A88dMyXK4I$|9zexG=@3-^9)K>S{)i+FGXERYoUdr&pP=IZ(8S$RA^u{T
z39=EA-$CZsLB+Yz#MeT_`O(BzLd8Xp#F5=8izE&*|1DI#BAWPPsJIqX9ONocK81yY
z2@df<s5mHmK<4MALHrepCY}QokB5rG%!ieGnNV?%IUx6cfQEAwk~qlx=}>d((8MP~
z#oN)uUqQvY(ZruY#iv5WVeWygbC{1qd<Rq<<W7)#G@$2i>_HP(gNmPkio?u@trNI}
zL;O8d9A>^R)SS;~;@(j4KTvUW^Vw#BL?HDtC>~+<%0tCr<`+TDQAQIlfQlPK#X+Va
zn`4VZJRT|zGk-eNoMbfdsZjA;s5s1g*gA)Ds5r<RP<l{+9&FcvBn}Gy!%%a2(8Tvc
z#iyc)GiN~3=S(#5pHTJlki?PgT@Dq8xf8a|VIx!==FR}9JNF@pgWOpLwf7L3co9_m
zG@AGpsQ7s_@ikEK8&Gj{_dJ4%qr2xlk~qjcBAJkI_>3kl02Tj(CLRD4XP6DL5m8?G
zK*c%H#QUJ)ylCQWP;nusILI_mx`M59&_NT2t#fch6Njx6@P>-R{M!Hx{}?23kbmDm
z?M*-ve+3oKL=zXxf`m^lnm9jHybMj;7AjtaCT<NCZ-$D){0nn`FH{`e{j-q7LGDk2
znllegJOL`c98J6(D!v*`ycH_G1x<W2RD1`T_(rJsVW>FF{jho7vpB?GLB&D-0=fSN
z)SP!{;@6<!-_gYXLdAchiT{R*v&;dx1d$GvvLW%sfhMj16&FMkcZZ6LqKUgg#pR&l
zAX`A`6XstH9OAA}ahQK|pyqg@iDyB@gP`K*=EvX=FNKQ3%%2D~rxH!PA1dAn6-PIJ
zG7j+#P;r>~+o0xbK@;Bs72gXLM>qdC4)F(2ahUnHq2@e66Tb-+{{j_9H~$|Faq+nz
zm5B7f06iF58cqBk)O-~*aaE{#4K#6OsJJy$9Apb}dT_-d9tRbN`PU0-P7<292UNTe
zDvoY`8&n)-PCit97n*o3RD3d29NnC`IK;O?#bM@8g_^SyO?)y`{0vka-TZ4f#NR>1
zVdn3Gn)3-wd<RsVbsorMM7sqx&&!WPTn8!+Gygu+90N4*yHIgUG;y|ENV#E)Ce8#E
zcS94mgNl2hiQ7QMgQ4OeUx3mH%>A)A#LJ-KF!v`z&8b2YPlSp$qltGx#oN)u+o0kT
z(8Lcx#iyW&AApL_go>lPe;rgD=FaC(^_$SdpF+iVL&ed}If_I49#kA=K5rf*ULK)|
zb3?^nqlue9#owce8$iW>po!-|#s8p*XF<go=Yw31nGVIE;xKnkgsPW96YqzL%R|LM
zrh(D}Y@LH0nmBBoLl~MkEd7+AiNog2>u`wAhKj@7xeMx^`Do%hpyDgg#P37J*Pw~t
zg^F)Q6KBbX#Me$VaVDtvAvAF<sQ587aSf>Wd8jxn++hB_i9`GwR2=4Cf2cXX(8PVA
z;>-&`CL`h(W<D<taW$wo%=}WQIa+Aq#ZYl8s5r<LP`ty;cflc^2o;B!KO1UJDw_CA
zsCXV!9Nqj19O4t9;xO|MK+TzoCcY0Uz7#5sZvJ{4;wPZuF!P^6%{hZ6{unBL6-}HA
zdNABgG;t27_#3D=x_iFi5a(YAQi*5}=tIpBMibYCiYr0ILAsFR%N!~W^H&H|y)~M6
z5LDa+DvoZB9}e*}s5s30DyTVGXyO%6@mi=jy7}!m#OFiBVdl?=nzI;9d@fXc8&n)-
zK5U-%01olHP;r>~N1*0BL=!&*6@P^${t_zw4o&<yRQx-dIDa9eocWC=&I=W1Sp;%9
zB45MY&xb=?9V!lUzX{YFZ8UKssJIE5cqCNZ0!=&|D(;9TUJn&_MH8=uihDuDLB0T`
zLzw&Hq2e%iE`h2~MiXBI70-c+qnlHPL%bg<4m1B0)SSs^;wPZubI`=!L&X=MiNA%4
zuS63UErP`3S~PKCsQ4zRIJ*0fL&ah4w1TQXjV5jZ6~6!#hnWLg=kOj)9JbDZV=+i2
zX8KV>6Njx6Fu)=12^ELAGa2e0Uo`PVsCXEf_ynkU6q<M+R6H3?d@EEu9Zh^QR6GYN
z4)Pr+UBTSnh$aqOC(w;Ud<j$>=C4~&^H-pW-++p5L=$H(hQ#|;G;vm__&zjo9jN#r
zG;uAc_-Uv(%wI6~U&SH*4k`|Fe<0MHPiW%)Q1Rbr;&o8*|7hYhP;rhWAeSKOoyAab
z9yIZVP;o)1I7k;LUSR7SETG~bcY@|MVDn$0XyUN>vi)e{F!d+U#9{Mll1o80LfnaL
zzA>73hzn%jcO;rP%=}z5@vG27U&_$LVfTeKqlv@r3!9H74l{o{4)FtM;;?(K?x2ao
z%z26?4!eJf0eVm&dN^~UiN~-&(rpl$IP9E?Xf$!yITaab;;?fnTF}H{?p%RGd?T9p
zGwAx-Gic&4bDrQ3|ARxEbvbH!fQ6?Jnm8=|=%R^l@Q0)m2Q+bSaY(q;pozoW*@`9(
zGk+~q9ONpf5nzLkK*iDH>kN`OXuR<fG=E({6F&wOe~2cYUII3r;VGJUEL8jzk~k>8
zz})!_NgQPFQ>gl1XyP}a;@m4hK7!;skopSf#0)>0cmY&g1W6oZFD%{_ki<de+=r@H
zK@-0Y71u-(2bm*S2Z=9JByo^Au4RyLutXELhl<-FiG$2hI{-1q3rQSg&J?J6KQ!?^
zsCY1vILI8>xfbzA;vjQgL)9mviQk2aXCR4#%z>SQQGz56GN-K^;;#xc@dl`PEs{9M
z9N2t)Cz3eGoU2gvy=da+q2kk^;-FXtrCULWwG0bzi0_4pgVHm|d<E#i&<D}P<)GrH
zq2e&}L2G3|R$Rp){s}4$Gv5_z&Nno1XQ=pps5rX$oGU>hkaiKsUod->pyDv|v!Ldv
zp^0Ze#SNk2Ak#qRw1XVaz`$S)6$hCEns;+xhDi7ziG#vtBGjA!H1S@jcqE$mb*OkO
zn)pSicp93xS|!BZEHrT?sCYh99OnLM5akSgXyWsr;xnM)Fn<+5{k0TH9OSPAsQD|=
z#ABf1o6y8(LB+SBiBE%y??)5A0u?`uCVl}begY~E^B1()&hP^&4st&zU%<+3*;OEw
zka7%JTn$YecAkt0nz%Fcphj;ralU7e@+1dM9A<ARnmFu!+cq?DE-pwwA3_s{nR6OV
z9Olj|XyW>|5cfPn6BmSzb8@W49u9(N;xO~2(8OWpYoLjDltb)|L=%U(KM747W_|&h
zxZoj(``XdO&p(5RuRs%rnZFH9y!<yr{dF{PnEIz^;<nK9#F(H5DZ|natbNFhCcf|j
z#J?hF;zl<i_8Opx!|V-#ii1>%LGv7l%7%)=?1iZ>MiK|*JCQ1oY6gaKG;uDdcn6wz
zH&na_O}rB-J`qVAlrLcQ^+Gi9I5kN6+=wO)t9SMyiG$p^32Od9H1Ty%@k?mpAE4sb
z(8OOr#qUGKVd2IJ2?mCjIK<i3f>c8CJIFmj(2EJV(8L3v;v!ISkS<WX2tm!4gNlRV
z1ys&AK%$*NA4wc!emT?}V>IznsJJau9A-ZBx<v+es5s304N&tVki<de&x4v1gC;%;
zDxQiaegi6=i6(vpDqai~hq(vjH;|WWafr`?ii6w<a*s$2NHqh)JT!43sQ3z~ILv%d
z+5+j=1QiFF1G4i0)W3(3#6jj;L(MskCT<QDzknuQ4i&$GCSC{?zl$b*94h`0P5dxa
z{25dn=6>k0kqiv$Kq8QK1t^_Bj~!y*f{MfZB>>4T4B|-QAb&B|f<l3TK^jf`FVtQY
zG;vF)dJQyjbEvp3k~k<lVfLCKiG%D-fU37b6OVz4*C2_5;tE#&Oh*%k-ABA0O&oUq
z+d(vOSUdSFnmDZ8`xZ?cW-se{NH~MS6XYJ)d4POq;xP5%XyPz?RnWv?_PU~p!_4tR
z6NlAPF=*mF(EU@jXyPz)rlX0&&PhIiCJs}75=|Ut?{zfs+t7nPf1ruO%wgPs8g4Li
z_|e2u|3lKD0h&0>96K~|Eg?vPjz$xQ#d|KAI4t}t(ZpflKNC$HX75HE;=9nqVg5RS
zChiQ~r~ML59A^G^G;ssydROU<sNn`vuYx8Hv)2esyif-cp8ja!u<%Jl6NiOQE}A$j
ze0tHuVeVOqLwp^YILw`U(8Rw8Li~9bO&n(aYcz4084!Q*Z-VH9<wux$2{dt-y=rLU
z)AmCOdUrH&m^s-v#7oe`g`xG=L^N@~DG>7?p^3xHe~l(?83s|$wi&y><Zy_ap^3xx
zFW94r!|e4y6Nl|z2tgBv?O(`86Ni~ofhG<MhpA}d3DA!20W@)#IX7^KKSUFU#p8Q4
zap$R!a1+>qBizu$a~?y|k3E_=%st^a#Pe~8Pr)I+6Nfm<R_yMS!6B}SCJq}{G)EI(
z3~dkRp^3x%H4lgQCNyza|6(_qIIMqh1Wg<^etQ;89M<o+g(ePj{~t7Qm^&4=VGkb*
z9OAJ!#7l9A*P)5S+|z?54(mtEL=(?qhPZDTnz%M}+-E<UI4nF*pozo6^CFr!EIe<a
ziNnVKpQDMx#{ZeOL)?X49`c}x!~83SCJq~iR7Vqsjq|&piNoT{7fl>Cu3LsC4pZNQ
zCJs}-0!<vI{wxmhYiQ!I^5H(3IBb02Et<F~blpG84%Bed4u|kn(Zpfy(L)o5*=vp_
z4zt$*O&m7f5`-r1Sq3S`s?o$@_O_sj!|a`eCaz!rX&23cii3OuUD6FM__jjDLFok4
z4xa;UZ|_7Cp9U2_1Qmyw1D(cUID<p{1ymen{u`({Z_vbFK*hg8#bM^d`nmsch)eGT
zsYLXn)#||BVvt7@SAvRbK*d42K;Zy0-w21eKU5s%{xqmL!D!-1Q1KY3IJ)_1IK-Qv
z;xO}<LCtAH6JG=s?}v(`n?DnW_*SSm%={-%b9SPMKZ1%MhKj??2lXLAA$k^v_*1Aj
z%zU1DkZJ~omuTW#Q1LHNahUng=}m@zIK;(vfm9;m*92;g6q>jZR9qQNJQ^yljwT)n
z6*qv2gKPn%2bg=TaEJ#%#bN$!hME(GCf*1Yk4F<<2Nh376JG-r&p{Kv3>7ax6Tb)*
zuY`)DyT2KS_#CJ>%>BQi<}5%H{|Oaei6*WF-B7d^O<V;kz70*>8!EmFP23YIz8@+M
zbH55C`7m6;A$|{s_;;u{%wNS&^M9j>7ed8Zc7tq$jFW)k9cC{d4skW8IL!RnP;<1<
z#AiaqjiKToTaeAS#UUOF6^EIB7-~)=n)pGecp6k3-TVR^;vG<NnE9`v=JcS6zl4fU
zgo?w=hhB5duoz7odhHU!A*eXWe9(A^ygo=L1H&n(IEV+`f(VY`r%-W_dQiP1(g+r2
zc!?&?2NnMW6^EGvE4TmP5SQ2kQi&)xQlRF@pou3y#Z{r=AYCAL!pzslA?^behq-?V
z)SLh`@dZ%vNT@iv`N=rM>!IQ>^PfP?X+{%&02S|nildu94Ttz9s5s1gr6x%DZ$lGT
zfQlc0io?u@)eEO^h(Cgg!_4=Bn)3`z+yg595h@NdA65?k#vv}e7o-vqzeP}U#L>hH
zpyCQ>;xnP*Drn-<q2jtwagZ&b^Z;{@ISz4us5s2O2chN!qlxc_ipQXdzk!M;pozbN
zif5vU3pPXID;G_iA1Yo36-Re}0}k<-P;r?1EurSjMH4rNiZ4SGPl1ZBLK9Ddif={}
z?}UnPM-y*{itmAn!`u%mpD*GNzl}ru3sfBDuZ>Xif1ru4hl(@q1K9|v7eMh2vzHr(
zxH426X8uj6IqGQQ*P-GDP;rng$mUz&5D$Wi!^~%Ffy8?ln)rXH`N>dmbn|m@h_^z;
zVdiT>&F@4LSBHxCLB(O_!|H`~P;rnspz<HqPq~ak{51~opJ?JQpyQzi`$0BB@;kEm
zmT2OBw;}2R(8OW=?npFoSid_7O&m5}QH3TBGp89%9A-`rnmDZgJ{3(I)_-4wCJyVr
z??V%Zh38c?aceV(f5oBm!|36!fF=&>C+eYzYh8i#H~rDXVe=XhXyP#UB%+DK#*OpP
z#Np${XyVDx@!VNx;xK!Up^3xnJ&z_1^VeN8@xp9~zy6_#!_4712njz}xP5en@O9C|
zVd~A$#9{Wjpox1y{gsL)4l}11O?+|(#GO;n#9`{^qKU)oU5zH5^#tPnGic&4b8exD
z-`ou;Pky6`!_;#^*E_(%r#uDXPAxQXnED_zaewIk`bso$Sbk|j6L&oUanEuzahUoI
zXyP#SH_^ml?s<eJ4hy#rXyT2~^%jDMA>jw}FU%ZyH1QZ{dFy~C4pSe2L%aZocqN)R
z%$@CM;{TxMTdqbEhuOOYO&n&<AvAG$SBO6!qlv@J`3e;WsRGA1^xPqyBOnpXa##dO
z9Mql<fz}riXyQIlaakmBP<fu*4z`6s6G<Fo&MByRT{Q7+P;nz9agaHCpzDep(Zo4-
zL(KO@5(k;TyA_h&0@1{mL&cNO#22(d)Tg0|&wz@Tqlt4t7vxo=iT{DBZ-9z}LKWmf
z4`?{ghl+#JA;_I8q2??`6JHJ$UkMe5nIi=?=LA$7X3jaN`ZH+aXQ1MjpyDudN}%R^
zgo?w=`3zP66;1pjRQxwo9A?gBs5xTLi_~G}NOVBLQwmL73@WY(6^EI_0loLc0V)nM
z2NdtHbnAg64hlC{s5w4p;?_{{KqPUHIr`86%~&LHkU84W14<In#J5AuNkb9`nbQni
zPg{f}4l*aQ58~f4H1WH=5b<gxagaH_(0y6$Na7%K(kDaIccY2NLd9pHi3d-CsGo->
zeiN#GF_JiFodyH61H1-F9ONFgZJ<=jz;F~v9ORxi(0SOCXyUJ+;^&~^uz36ejmLLT
zaZo&h%n_UkapxyAaek=ycc?hJIYP%kB9L+kWR4kBy%?If2~=DjDh|>G@{v09J{L_K
z;%-oJm^)*k=6IorM?%Ge(ZuIM#lz9WXG6skq2e(2I6>W$jYGTxDh_kc5vVymXyS*U
z;#1MYKSIT4qKUtUiZ6zW!`u@Db<bKH;-{eEF!xBzg2dxFG;uMg_;oaKSE%@HG;wFB
z_*1Aj%squr_q@j;&T$;15|JKqpyu$PiDyB@MbX4(Ld7M~#HT~W6`|rFTR`b&64X78
zP;po|9Du5KMHAl#759RQqnnco6^EJg6skTGP5d!bya*}|Gv^r8JvBJQXF|nc=JU*k
z#MfLjaSo{XGBj}?sQ4;0aWAO&7N|JPJrAMo*@r{?HdGwuo?@su_tC@)q2e#l#1}xt
z-=K-lgNlEHio@LV5$Ya>6Ce>te;*W&FmYL^ILtlAq2?%}i64cEYoUpMfr{&)iGPBM
zTR_D@wu9^yfSyC^ghM<UDh_jx^c+Zh#iNN!Ld7%C#66(mIcVZ;Q1KF|ILtkUQ1?uM
zio@*9hpL}}CY}owp9>X7H)jV_9A?fGsQNu<;*+4_N1@^{bJjxLa~>)VG6z&oEr8Zj
z50Jz`<^OJ|IZx2Uw?oBWB8elL^9e~DWX@Np`fq6BAEDxmCqXVmq#tLfJGpU)Ye2<8
z?gyE#I~Nj<I%wkBP;pZ<@hGUcC7O5yRNNUV4ssPJT?Iqk<BLN)3n~tCPb1WvJT&oo
zsCYS=_&TU~HJbPusCX+>9Oj-PsC)Wxh_8W)!`yQfYR(2U@yk&0ooM1r(2XK{(Zm^`
z;>V%lF!#)Wy5}Me@mElBn0vIL=Db4_SBHv!M-$J6ivLCv&xDFIp8~lAk$zaEA?ZOG
zDh{)E5>&l9n)n2$xDHetWEv>mVdl6)#bM@bhpP8R6W<CI4}prq%&~;JCk}^rHB=mC
z{ynHU^=RU^pyC~9;&SsL{_Q~%mw}2;gNno469{$B0vzIdq2e(2xI)c2h$ij~6+eY0
zUIZ0ChbCSC6~6%$hq)&a>Yhh9#Q#IZVeXj;HHY~$$OJ_DWI9xw2TlAKR9pZ}{0LNB
z3MvjV4HWMUQ1__d5VwVj!`$;0YK|kC_-m-R7n-=#0!V!Mp@~aC#lxWDF!wBkx~B{(
z4zt%0s=f+M+#V`k4;4o@XBJc(W=<MZ{X8`B6sY)es5s1=t5ElB#36nTDh@Nh7i!KW
zH1STT_-!=tvrzH-XyT`#;xD1%F!#KLy5}<vah@|Em56lm1!|4}n)oNExFnjm;zCG#
z$)btNL&a5*#6k670kl3fMG^<qQyx(DmT2N`P;omXab$CRk;Fmf<U-X4qKRii#iO9&
zAYX&hvyKeJ{V6!a8=>N`_?iMWrxi_n0#v*YP5cT}d=i@YC8+ous5s0$4p8?j!y&#O
zDh_kcZ>Twk(Zqj3#m}ILYb=8J_X3)@8dUryk~k=w4WJuhA0de&_tSqPiG#x5A8O8j
zG;v?3ILld(PZ9Oe45)uqpyDupl|a>Npotej#dV?LAk#qc2s6h6Dh@MeCRDu-n)r06
zcqmjHX3lA-d*X43*FeQ#<{yBX(|{(v2P)o)CeE-J68^nt;{TxPr$fbI?s*1v&q5sH
z`=H`5_oze7KZGW(3Kc(%CLRJ6KaVCJ1Qovt6^FU!8`M3IafmaV1F1xmC)H4MSkS~P
zq2jz~;wzxyf@tE)pyJX{agZ&bco&t0gr_PFaXY9uEPT#G&2d5#KMNK2Mic)7757II
z{{<Bfhl<18V+M6kIaC~GuksRzJFC&e6`|q{P;qo~W<$kc=6FEW&qot?gNm<!io?vw
zg1ToD4)OC)ahUn}P;)M$iDyH_@1TjVhl)Qy6JHAze+3nXxu+HCo-a7W1<!+2BGS(_
zs5zo&;#Z*Ja%kerOCjN`geJ}i71x1^gKPn%pQ%vynBfo)hKj?&M+<6BIGVTyR6GGq
zJRB;Xf+ijc70-i;!`!n4>YfT5;uE3bF!$6!&6$cOUIP`MhbF!nD!vF!d?i$T6;vGN
zo~uyzoPvtO?7ak4e-2Ij0#y7mR2<!$cTjPdIp3k`KcR_#g^K@%io?tagkJQ*dI2N?
zNhhFs>H@T$5<?OP)kg};An8F0O<W2pE{`ORY>oz!ILMsIQ1v=!;{8x@bEr7TRiJeB
z92#zpIK<<i;;?Wy4K*hTP5dNOJR42?2UI*CP5c{Fyb>x7bI*6Edzx{GFMx`}+#|mn
z5^hV-#ATu4Yth7gpyC_R#J!;6yP@JR_lQB`@hA@QM^JH?dy1jvJVO&Ngo?jM6JG!o
z|BNO+4=Vl_Dh_jx4b(mC7eOM3_6bZ}0V)o2&q=5`Drn+Iq2jt|;+!iW;c18_&JGo~
zgo=Y~2c@5tQ1?Va#bNduK-I^hiR(edlc3`0=F~#PVdjKF)i<Jv2SdfXpyDud?n2!&
z1&8=Xs5s308mKv2(ZnmD;``9V_dvxDp^5K;il2ds!`$-~>Yi&j#6LsDVeWYhHRn5;
z_(P~T!zGZ(kn#kS-vyut+_RvG^FhV=pyD81p!i~iF5r{EA#Ms4hq=cbYK|qExG7ZJ
z2~9i&D(;3Ro&*&SfQrN1qXKnL6b|uXs5s0$-B5GN(ZoBU;tgoxJD}n%XyV(T;yqAt
zn0s8I?pXsBhuM1{s(u5S_+6;@R;W0-ITxVfFmqT|LGsrXG;t=V_+6+t%$!Q7d!FME
zXSobgiAWFHP;)rY#MPnVf@tE|P;pT-@l2?=JX9QH3n=~cLfxZ@L)-}}4)gCMs5x$E
z;uE0a{%GR+q2j@4;(MXu(MaN;dT;@>KFvlF2jz=rQ1$s};!mLBB}n4P<}@RTgUsPx
z4T-OIG;vO-_ynjpEPT#D!)F!_@$FD?Soj!0&Do76t_KxAf+k)B6+eL{UH}!p1Qmz5
z=N8mGcW{V*g^I)6GZSjgPc-rAP;sU!Ad?a4?HE*?4Nd$ARGc4492Cw80+8@jK@tar
z^INET4K(rBP;p(TILLNTI<$daAmj@bhq+$}dI3ftnz#T|JPaz1ZcZUo9A=I=RDCI$
zxG7Y;4k`{aCm-sb4jkf3q2e&}<DllOL=%sKif=*_p9dA+h9*7-Dt-Ve4s%Zv)IFzg
zh(Cvl!`yQeYR+pk@xxH@FKFVQpyEH!#6LjAnXZCdf@q&ifVzhVhqx+K9OfR$wUBh8
zi6$-%6*oc?cY}(Xp^3Xd#qFTtAXkCX&qAns;-KO%dvl@clhDMoq2lRKaddN<pyDud
zCPCG=p@~m`iuXgsVdh+gx@RU1@oi9XnE5-Q=IlZf-wG8!j3)jQDt;VI{5w?qB2*ma
zo)=K}+{PjP11b)4kHR`geEmTamxGG4UIUqoC^vke;+$yW-cWI2s5nR$D89Zy-6M-b
z+zcuXb59A>94j>OBB;1Cn)pJfxI3Eoe5klTR2=3Wc14JP^P%D}drv^s7o&+EgNj!`
z#nH`~3>Al&^A@UpI-2-vsQ3b?ILsV(sC!mH#X;tP%3B6#{kR)R98}(lt%taOKbp7z
zRQw2%II=lsk;FmfbVAi%L=$g?ir;~X!`#USb>}l2;>_1UDiP`AAk-XoH1YjVaRD^(
zcTjN=H1Ri3aXF|s$QDq#l7YHM1BbXPR2&qZApeSPfP|YTnz%4jJP1wP2`V0jChh<g
zPk@TU++zfFPZkdGW~eyKJ=sum+R?<*q2d$J#8*Sbr=W?igo@9Bio@J91L~eVP;r>O
zm!Rqopow3AiXVlFqnq;pDh@N}J5>D>H1V%c@wZTMm^o*l?)i>GT;v8wB_jREZG^;^
z1e&-MR9q2FJPs<ZiY6Wd71xJ~gKPn%pL<aESmF>5f{MfZ+X^)&3{AWlDjts}z6mOx
zj3&MTDxM7$hq>n+)IHr$ahSa~q3Zk5#IHler$EKg%~=l>hne#as(v$?_#deF9;i6X
z93|+*y~l8fKZc6K%vaq6iLd8q;)+o54`|}4Q1LHl;>l3)e^7Cld;Fm8;eek1hc2!N
z6^FT}2WpNgns^sfTn|lrCsZ7^Zw6-0cBr@&l6p|NdI8!V_CgW|l`{{Z>iy8f??J_b
zk;IYBNkS3_nZvpn5}s*j;>=L-e5g1q9J-<5Q;9=-8dMzSFCC~kv(UsfpyG?s#B-qH
z%hANMpyC^$;xPAYhPr1r4)H5cahQ81L(RE?CO#1={t!+4095=bn)p7b_&X$VP&gmp
zhlD5dEszTl<;-)adUiDNr%-Vos5nR$sNCRGhM1!R6^FT>XA4B!08N|=DsBoDM>i(`
zDh@Np5UM@|O<W%;9t#zRnPUfaPdX0q7N|JP{0OKy9cbbqQ1OXq;xnM)Q_;kyLB;1o
z#bNFVfx2fU4)J49ahQAdL(MsbCcYOcei=>t4OIL(n)oZI_(P~T%soj^_q@g-&I#Rb
z2Xl|`R!BVZqKOMa#YLgwF!PI{=9@yrVdhvs)mx&8n?c3xpyKG}L_)=3=EOqP$D)Zx
zL&eje;xKboLfun<L%bI%4l}<6YR*J7@dl{)EHv>WQ1N+a;)kH(E1=>q_w0wdXA=(b
z^H6b^dtO7$xr`?M5-NTNO<ZCdB)%S?iHkwSUqQuT?l}u}&leoxLU%wa5#@tD)EqH1
zaa*Xk98?^n3sgQlfSPXy6^HpN1*+Z&O*{!I?hX}4Hzx@y4l}0{sy+=(yd5f@4;6=*
zBMIFAT!}+`8dMx+{syQyv(UuXK*blMiGP5KFGmx92NmB46^FS;59*%XIK;0&#bNFd
z-wui28))L9Q1ORo;x16}r)c6%Q1Q1=ahQAjpzh(l3lc%Zdp1<PAewk4R9p-y4$=jR
zcbGYbP;r?1CqUJkqKWrG#qFTtFmu|V?(x7Oo(dI*nZF%sP9~c8W~g`(n)r99co~}b
zSEzUcR2=4>8Bq6h;SgUA6^FS;4tg=_YBX^fsQ4B%ac`*j4m5F3sQ4kMILtlEpzb+?
zL;Mv~9Oj-Ps5$S@#0#L}-=N|!^AAAH7rO@%L8OQ2Q1w!1;!~mG@=$S*E>L=anPUYN
zhq-4DRJ|RV_%5ipJ5(HI&Nrxg0&$4vLB(O_KZcr9geHC;Dqf8yuDlbHzv|J%6`|st
zP;r=hlvE+=C*u&`02PP1#|vuC7Bq1WsQ6wq@p7p6K{WAFsQ789ILti;Q1@KLA^sUE
z4s*{us5#%!#OFZ8|09Wm+KmR#c0T`okd27+a2Tpy7)|^jR9pf{9N8RoBymtX{{>XN
zHk$Y|sJIDK9ArBvT@^w7YllNT8Y&L+FaIt`e8r=Qb3?^5(8T?r;yGyIzEJTps5s0$
zv!L#2z#%>tDh_i`8PuGGXyPSM@l|Nzi=pD{(8L!)#dko(VeVN0b<ZIj;t!zWF!!8-
zn)3ur`~+0|Es{7W9zXCw!jtI%$VNnZcn?+2h9>?ND$WfR2k8REBO~Z?Ck6%vZKycR
zJtENk?D}ZpLQruNs5rVg{!nq4IhIiM!D!;<Q1KY3ILsUqsC&|Ih&MyUVdf`5&1pvy
zkAaF$Koeg86`z78J`XBB4=N6Gj|bE}D{zP(g^I)6a~x{UNi^}JQ1MG>;$NWR*U-d2
zLB$_H#bNFVhq~t#4sqs(AeD&pAiW2YPT0}JC86R1XyP7FaS=3eH>kJ_R2*arDE$;d
z-D3k4hlN8vRJ{Y5crH}j6)KKyP6AXMX3i9-`V=(rNl@`zs5s1=rBL^j;}D+$6^EI>
z8*0uBH1X|F@r7vOzoFtw(Zqj3#n(f{VeZ)hb<a*5;+LS}F!w0!g~Zo2G;sx}_<b~S
zf2jClG;v?3_-m**%snTe?%{p}5<#SsGN^ifH1QIsxCm4nqze@9Fmv>w;xPBmhN?G4
z6Q2ncw}Fbo%=rg(j~i4RWDcl&n*bdr2}cqK)l)~H=0u~3?}LgbAc-TJlZhk_GRJ%$
zB%E{6#Eqfi6;N@QJ1;}s*@Q!UK2#j!evtY3P;(ZeiRVJa*Pw~dfr@WH6Q2bY-vt$i
zx#uO+Jx6ee--U|9+;bFa&O<cugHZ8TXyUB<A>s25O`I7j{tYS)bC16|M7`K!kO(4O
z=|I&>p^0lj#pR*mAYGtz1vAGADh_jhAXL2_nz%ny+#M<oGp8Bqo<JPpc~Ehf`4v!e
ziqOPMpyJhN;ya+?^=RVTpyHiSahQ9iL)|kOhxi((ILtlwq2_Er6Tb@;--#y91HGtw
zFPb<PRQxDZ9Oj-CQ1?8Aio@(RhN^#wCT<87e+LyuH-{5?UJlHh2&j5qH1RN~xENF%
zX3ia`dlYbp+d{=*=GQ~baYPfZhKhTkiSLJs`=N>Ng^EW&#bNH@(14`pBpl+^P;r=h
zo<Ys2M-zVn74JY37d{9vzXwfR5Gp<eNgPy;B|yu=B}n3+a>fd(eg&Gi1yp=3k~p$C
zdyvFI=EOtQA3zh2g^Hhqio?Rk4H`a|afp9_io?RE4QkF8H1Q^=_+K>fV^DF%ryv^<
z<;fAKI5$)rBnv7x@}TY!#UZW-6^FU!Ez}$%H1XF^aceYjsY8(XvPTn_fQow{iG#w~
z0NOr}MG^;vvm;b}BAU28R6GqT4)fPBsK45v;xPB8LDhGmiKjrt`=R16b526dSp^k`
znbQqbzYa~j6DqzPDh@N}8`PYGIK=Nk#bM@ef|~OPO?(|x{56{RC#d*)H1Q8m@t;s}
zn0q)hA@RZty*CV9Tm~u*bC2X<h<XJyadD`)CYrb#R9qKL+yyFb3KfUhD*<&+C{!F~
zZ!T1QB${|OR6GtUj&4pRR2*i`B&hmYH1P>g@iwS9%p5PMdnVuzUkeq7nZFZi&PFux
ztx)k@XyQMi;``9VzeB}OK*eG1iG#Z55)Sd#P;r=h6pldR>phyd98~-Vnz%1i{12MA
zH&mSEImji5b!B-__ozU{VfL0l)oY-M7eU2!q2eIZz~v9r91o~C%$%7}^*(6g)1l&_
zP;r<!i=gJjL&ZVnfXb5t(DI}JNgPz39D<rtf+oHPDqe{sj%-d7k~qj5)1#1ZZbK6{
zgo;muio@Jl0d?nW9O65m;vn~f%+H0Ivj<H)8!CPjO?(zq{3M$A45;{Js5s0$y-@eu
z#UcI;Dh_kcVW>I3(8Tvc#hG7#Oh(i@%*P<%!;U7-2o>jtii324(!)ond-S2=FnhJ2
z>W$IFHK5`aP;qo~f}!FtbNr#|!_mZjq2dWpahN&E(EDPtaEP}<#bM@`LCxt#6EA{_
zPeBvk1{I%yCcXtKz6dG~bB{UHJ!^1?ABBp;+;bOd&Pg=!+feaKXyRPQA@Ow$O`HQN
zeh(@RbB{aJJ^!HMFnbN5>X}}GR3g%YK2)3?Dh`qb#XHO#C8#*eoG_?*H8k-MsJK2<
z9A-`>)IF9s#KWNCF!O7n=0u^1S3<>;(Zu&c#naKmcSFSsq2e(2EQPwK8i)84s5s0$
zPoU<^Kofri6<>%ZE(krZaw(cPKU91zk~pXwn*c2j_acdd${7o&`h#fVW>E2CNaD!m
zTtyNGnG*|De-lkS8Y=z>Dh>;u2hi|&gF~G26-Xr_{j@;M;YAZ~fQpNui64QAOQDG$
zf{Lp^#X+`!(jkX7B>n5*5O;@)!{X~T)EsX#@t08X5HxX#lMwSG(8R@{;)zgkn0ux{
z	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�ij6=K|O*|K>ej}Q=6jXdCnz#~F
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
literal 0
HcmV?d00001
--
GitLab