diff --git a/.README.md.kate-swp b/.README.md.kate-swp deleted file mode 100644 index a3a8dcc..0000000 Binary files a/.README.md.kate-swp and /dev/null differ diff --git a/README.md b/README.md index 854f24e..0274387 100644 --- a/README.md +++ b/README.md @@ -26,6 +26,14 @@ install -Dm755 reforger-surround ~/.local/bin/reforger-surround ## Workflow +```bash +reforger-surround launch +``` + +This runs `up`, launches Arma Reforger through Steam, waits for the audio stream, then restores normal system audio while keeping Reforger exposed to the 5.1 sink. + +Manual workflow: + ```bash reforger-surround up ``` @@ -48,6 +56,7 @@ reforger-surround down ```bash reforger-surround create # create the 5.1 sink only reforger-surround up # create sink, save default, make 5.1 default +reforger-surround launch # up, launch Steam app, wait for stream, restore reforger-surround expose # move running Reforger stream to the 5.1 sink reforger-surround pin # alias for expose reforger-surround restore # restore previous default, then expose Reforger @@ -62,6 +71,8 @@ reforger-surround check # report whether Reforger is 2ch or 6ch REFORGER_SURROUND_SINK_NAME=reforger_surround_51 REFORGER_SURROUND_DESCRIPTION="Reforger Surround 5.1" REFORGER_SURROUND_APP_NAME="Arma Reforger" +REFORGER_SURROUND_STEAM_URI=steam://rungameid/1874880 +REFORGER_SURROUND_WAIT_SECONDS=90 ``` Example override: @@ -70,6 +81,12 @@ Example override: REFORGER_SURROUND_APP_NAME="ArmaReforgerSteam.exe" reforger-surround check ``` +Use a custom launch command: + +```bash +reforger-surround launch steam steam://rungameid/1874880 +``` + ## Expected Result Good: diff --git a/reforger-audio.carxp b/reforger-audio.carxp new file mode 100644 index 0000000..97c4098 --- /dev/null +++ b/reforger-audio.carxp @@ -0,0 +1,379 @@ + + + + + false + false + true + false + 200 + 4000 + + + + 120 + + + + + + VST2 + ReforgerEQ + /lib/vst/carla.vst/CarlaPatchbay16.so + 1131572326 + + + + Yes + 1 + 0x3f9 + + +PD94bWwgdmVyc2lvbj0nMS4wJyBlbmNvZGluZz0nVVRGLTgnPz4KPCFET0NUWVBFIENBUkxBLVBST0pFQ1Q+CjxDQVJMQS1QUk9KRUNUIFZFUlNJT049JzIu +NSc+CiA8RW5naW5lU2V0dGluZ3M+CiAgPEZvcmNlU3RlcmVvPmZhbHNlPC9Gb3JjZVN0ZXJlbz4KICA8UHJlZmVyUGx1Z2luQnJpZGdlcz5mYWxzZTwvUHJl +ZmVyUGx1Z2luQnJpZGdlcz4KICA8UHJlZmVyVWlCcmlkZ2VzPnRydWU8L1ByZWZlclVpQnJpZGdlcz4KICA8VUlzQWx3YXlzT25Ub3A+ZmFsc2U8L1VJc0Fs +d2F5c09uVG9wPgogIDxNYXhQYXJhbWV0ZXJzPjIwMDwvTWF4UGFyYW1ldGVycz4KICA8VUlCcmlkZ2VzVGltZW91dD40MDAwPC9VSUJyaWRnZXNUaW1lb3V0 +PgogIDxMQURTUEFfUEFUSD4vaG9tZS9zY29vdHovLmxhZHNwYTovdXNyL2xpYi9sYWRzcGE6L3Vzci9sb2NhbC9saWIvbGFkc3BhPC9MQURTUEFfUEFUSD4K +ICA8RFNTSV9QQVRIPi9ob21lL3Njb290ei8uZHNzaTovdXNyL2xpYi9kc3NpOi91c3IvbG9jYWwvbGliL2Rzc2k8L0RTU0lfUEFUSD4KICA8TFYyX1BBVEg+ +L2hvbWUvc2Nvb3R6Ly5sdjI6L3Vzci9saWIvbHYyOi91c3IvbG9jYWwvbGliL2x2MjwvTFYyX1BBVEg+CiAgPFZTVDJfUEFUSD4vaG9tZS9zY29vdHovLnZz +dDovdXNyL2xpYi9seHZzdDovdXNyL2xpYi92c3Q6L3Vzci9sb2NhbC9saWIvbHh2c3Q6L3Vzci9sb2NhbC9saWIvdnN0L2hvbWUvc2Nvb3R6Ly5seHZzdDov +bGliL3ZzdC9jYXJsYS52c3Q8L1ZTVDJfUEFUSD4KICA8VlNUM19QQVRIPi9ob21lL3Njb290ei8udnN0MzovdXNyL2xpYi92c3QzOi91c3IvbG9jYWwvbGli +L3ZzdDM8L1ZTVDNfUEFUSD4KICA8U0YyX1BBVEg+L2hvbWUvc2Nvb3R6Ly5zb3VuZHMvc2YyOi9ob21lL3Njb290ei8uc291bmRzL3NmMzovdXNyL3NoYXJl +L3NvdW5kZm9udHM6L3Vzci9zaGFyZS9zb3VuZHMvc2YyOi91c3Ivc2hhcmUvc291bmRzL3NmMzwvU0YyX1BBVEg+CiAgPFNGWl9QQVRIPi9ob21lL3Njb290 +ei8uc291bmRzL3NmejovdXNyL3NoYXJlL3NvdW5kcy9zZno8L1NGWl9QQVRIPgogIDxKU0ZYX1BBVEg+L2hvbWUvc2Nvb3R6Ly5jb25maWcvUkVBUEVSL0Vm +ZmVjdHM8L0pTRlhfUEFUSD4KIDwvRW5naW5lU2V0dGluZ3M+CgogPCEtLSBDYXJsYS1SYWNrIC0tPgogPFBsdWdpbj4KICA8SW5mbz4KICAgPFR5cGU+VlNU +MjwvVHlwZT4KICAgPE5hbWU+RkwgRlI8L05hbWU+CiAgIDxCaW5hcnk+L2xpYi92c3QvY2FybGEudnN0L0NhcmxhUmFjay5zbzwvQmluYXJ5PgogICA8VW5p +cXVlSUQ+MTEzMTU3MjMyMzwvVW5pcXVlSUQ+CiAgPC9JbmZvPgoKICA8RGF0YT4KICAgPEFjdGl2ZT5ZZXM8L0FjdGl2ZT4KICAgPENvbnRyb2xDaGFubmVs +PjE8L0NvbnRyb2xDaGFubmVsPgogICA8T3B0aW9ucz4weDNmOTwvT3B0aW9ucz4KCiAgIDxDaHVuaz4KUEQ5NGJXd2dkbVZ5YzJsdmJqMG5NUzR3SnlCbGJt +TnZaR2x1WnowblZWUkdMVGduUHo0S1BDRkVUME5VV1ZCRklFTkJVa3hCTFZCU1QwcEZRMVErQ2p4RFFWSk1RUzFRVWs5S1JVTlVJRlpGVWxOSlQwNDlKekl1 +Ck5TYytDaUE4Ulc1bmFXNWxVMlYwZEdsdVozTStDaUFnUEVadmNtTmxVM1JsY21WdlBtWmhiSE5sUEM5R2IzSmpaVk4wWlhKbGJ6NEtJQ0E4VUhKbFptVnlV +R3gxWjJsdVFuSnBaR2RsY3o1bVlXeHpaVHd2VUhKbApabVZ5VUd4MVoybHVRbkpwWkdkbGN6NEtJQ0E4VUhKbFptVnlWV2xDY21sa1oyVnpQblJ5ZFdVOEwx +QnlaV1psY2xWcFFuSnBaR2RsY3o0S0lDQThWVWx6UVd4M1lYbHpUMjVVYjNBK1ptRnNjMlU4TDFWSmMwRnMKZDJGNWMwOXVWRzl3UGdvZ0lEeE5ZWGhRWVhK +aGJXVjBaWEp6UGpJd01Ed3ZUV0Y0VUdGeVlXMWxkR1Z5Y3o0S0lDQThWVWxDY21sa1oyVnpWR2x0Wlc5MWRENDBNREF3UEM5VlNVSnlhV1JuWlhOVWFXMWxi +M1YwClBnb2dJRHhNUVVSVFVFRmZVRUZVU0Q0dmFHOXRaUzl6WTI5dmRIb3ZMbXhoWkhOd1lUb3ZkWE55TDJ4cFlpOXNZV1J6Y0dFNkwzVnpjaTlzYjJOaGJD +OXNhV0l2YkdGa2MzQmhQQzlNUVVSVFVFRmZVRUZVU0Q0SwpJQ0E4UkZOVFNWOVFRVlJJUGk5b2IyMWxMM05qYjI5MGVpOHVaSE56YVRvdmRYTnlMMnhwWWk5 +a2MzTnBPaTkxYzNJdmJHOWpZV3d2YkdsaUwyUnpjMms4TDBSVFUwbGZVRUZVU0Q0S0lDQThURll5WDFCQlZFZysKTDJodmJXVXZjMk52YjNSNkx5NXNkakk2 +TDNWemNpOXNhV0l2YkhZeU9pOTFjM0l2Ykc5allXd3ZiR2xpTDJ4Mk1qd3ZURll5WDFCQlZFZytDaUFnUEZaVFZESmZVRUZVU0Q0dmFHOXRaUzl6WTI5dmRI +b3ZMblp6CmREb3ZkWE55TDJ4cFlpOXNlSFp6ZERvdmRYTnlMMnhwWWk5MmMzUTZMM1Z6Y2k5c2IyTmhiQzlzYVdJdmJIaDJjM1E2TDNWemNpOXNiMk5oYkM5 +c2FXSXZkbk4wTDJodmJXVXZjMk52YjNSNkx5NXNlSFp6ZERvdgpiR2xpTDNaemRDOWpZWEpzWVM1MmMzUThMMVpUVkRKZlVFRlVTRDRLSUNBOFZsTlVNMTlR +UVZSSVBpOW9iMjFsTDNOamIyOTBlaTh1ZG5OME16b3ZkWE55TDJ4cFlpOTJjM1F6T2k5MWMzSXZiRzlqWVd3dmJHbGkKTDNaemRETThMMVpUVkROZlVFRlVT +RDRLSUNBOFUwWXlYMUJCVkVnK0wyaHZiV1V2YzJOdmIzUjZMeTV6YjNWdVpITXZjMll5T2k5b2IyMWxMM05qYjI5MGVpOHVjMjkxYm1SekwzTm1Nem92ZFhO +eUwzTm9ZWEpsCkwzTnZkVzVrWm05dWRITTZMM1Z6Y2k5emFHRnlaUzl6YjNWdVpITXZjMll5T2k5MWMzSXZjMmhoY21VdmMyOTFibVJ6TDNObU16d3ZVMFl5 +WDFCQlZFZytDaUFnUEZOR1dsOVFRVlJJUGk5b2IyMWxMM05qYjI5MAplaTh1YzI5MWJtUnpMM05tZWpvdmRYTnlMM05vWVhKbEwzTnZkVzVrY3k5elpubzhM +MU5HV2w5UVFWUklQZ29nSUR4S1UwWllYMUJCVkVnK0wyaHZiV1V2YzJOdmIzUjZMeTVqYjI1bWFXY3ZVa1ZCVUVWU0wwVm0KWm1WamRITThMMHBUUmxoZlVF +RlVTRDRLSUR3dlJXNW5hVzVsVTJWMGRHbHVaM00rQ2p3dlEwRlNURUV0VUZKUFNrVkRWRDRLQUE9PQogICA8L0NodW5rPgogIDwvRGF0YT4KIDwvUGx1Z2lu +PgoKIDwhLS0gQ2FybGEtUmFjayAtLT4KIDxQbHVnaW4+CiAgPEluZm8+CiAgIDxUeXBlPlZTVDI8L1R5cGU+CiAgIDxOYW1lPkZDPC9OYW1lPgogICA8Qmlu +YXJ5Pi9saWIvdnN0L2NhcmxhLnZzdC9DYXJsYVJhY2suc288L0JpbmFyeT4KICAgPFVuaXF1ZUlEPjExMzE1NzIzMjM8L1VuaXF1ZUlEPgogIDwvSW5mbz4K +CiAgPERhdGE+CiAgIDxBY3RpdmU+WWVzPC9BY3RpdmU+CiAgIDxDb250cm9sQ2hhbm5lbD4xPC9Db250cm9sQ2hhbm5lbD4KICAgPE9wdGlvbnM+MHgzZjk8 +L09wdGlvbnM+CgogICA8Q3VzdG9tRGF0YT4KICAgIDxUeXBlPmh0dHA6Ly9reHN0dWRpby5zZi5uZXQvbnMvY2FybGEvcHJvcGVydHk8L1R5cGU+CiAgICA8 +S2V5PkNhcmxhU2tpbklzQ29tcGFjdGVkPC9LZXk+CiAgICA8VmFsdWU+ZmFsc2U8L1ZhbHVlPgogICA8L0N1c3RvbURhdGE+CgogICA8Q2h1bms+ClBEOTRi +V3dnZG1WeWMybHZiajBuTVM0d0p5QmxibU52WkdsdVp6MG5WVlJHTFRnblB6NEtQQ0ZFVDBOVVdWQkZJRU5CVWt4QkxWQlNUMHBGUTFRK0NqeERRVkpNUVMx +UVVrOUtSVU5VSUZaRlVsTkpUMDQ5SnpJdQpOU2MrQ2lBOFJXNW5hVzVsVTJWMGRHbHVaM00rQ2lBZ1BFWnZjbU5sVTNSbGNtVnZQbVpoYkhObFBDOUdiM0pq +WlZOMFpYSmxiejRLSUNBOFVISmxabVZ5VUd4MVoybHVRbkpwWkdkbGN6NW1ZV3h6WlR3dlVISmwKWm1WeVVHeDFaMmx1UW5KcFpHZGxjejRLSUNBOFVISmxa +bVZ5VldsQ2NtbGtaMlZ6UG5SeWRXVThMMUJ5WldabGNsVnBRbkpwWkdkbGN6NEtJQ0E4VlVselFXeDNZWGx6VDI1VWIzQStabUZzYzJVOEwxVkpjMEZzCmQy +RjVjMDl1Vkc5d1Bnb2dJRHhOWVhoUVlYSmhiV1YwWlhKelBqSXdNRHd2VFdGNFVHRnlZVzFsZEdWeWN6NEtJQ0E4VlVsQ2NtbGtaMlZ6VkdsdFpXOTFkRDQw +TURBd1BDOVZTVUp5YVdSblpYTlVhVzFsYjNWMApQZ29nSUR4TVFVUlRVRUZmVUVGVVNENHZhRzl0WlM5elkyOXZkSG92TG14aFpITndZVG92ZFhOeUwyeHBZ +aTlzWVdSemNHRTZMM1Z6Y2k5c2IyTmhiQzlzYVdJdmJHRmtjM0JoUEM5TVFVUlRVRUZmVUVGVVNENEsKSUNBOFJGTlRTVjlRUVZSSVBpOW9iMjFsTDNOamIy +OTBlaTh1WkhOemFUb3ZkWE55TDJ4cFlpOWtjM05wT2k5MWMzSXZiRzlqWVd3dmJHbGlMMlJ6YzJrOEwwUlRVMGxmVUVGVVNENEtJQ0E4VEZZeVgxQkJWRWcr +CkwyaHZiV1V2YzJOdmIzUjZMeTVzZGpJNkwzVnpjaTlzYVdJdmJIWXlPaTkxYzNJdmJHOWpZV3d2YkdsaUwyeDJNand2VEZZeVgxQkJWRWcrQ2lBZ1BGWlRW +REpmVUVGVVNENHZhRzl0WlM5elkyOXZkSG92TG5aegpkRG92ZFhOeUwyeHBZaTlzZUhaemREb3ZkWE55TDJ4cFlpOTJjM1E2TDNWemNpOXNiMk5oYkM5c2FX +SXZiSGgyYzNRNkwzVnpjaTlzYjJOaGJDOXNhV0l2ZG5OMEwyaHZiV1V2YzJOdmIzUjZMeTVzZUhaemREb3YKYkdsaUwzWnpkQzlqWVhKc1lTNTJjM1E4TDFa +VFZESmZVRUZVU0Q0S0lDQThWbE5VTTE5UVFWUklQaTlvYjIxbEwzTmpiMjkwZWk4dWRuTjBNem92ZFhOeUwyeHBZaTkyYzNRek9pOTFjM0l2Ykc5allXd3Zi +R2xpCkwzWnpkRE04TDFaVFZETmZVRUZVU0Q0S0lDQThVMFl5WDFCQlZFZytMMmh2YldVdmMyTnZiM1I2THk1emIzVnVaSE12YzJZeU9pOW9iMjFsTDNOamIy +OTBlaTh1YzI5MWJtUnpMM05tTXpvdmRYTnlMM05vWVhKbApMM052ZFc1a1ptOXVkSE02TDNWemNpOXphR0Z5WlM5emIzVnVaSE12YzJZeU9pOTFjM0l2YzJo +aGNtVXZjMjkxYm1SekwzTm1Nend2VTBZeVgxQkJWRWcrQ2lBZ1BGTkdXbDlRUVZSSVBpOW9iMjFsTDNOamIyOTAKZWk4dWMyOTFibVJ6TDNObWVqb3ZkWE55 +TDNOb1lYSmxMM052ZFc1a2N5OXpabm84TDFOR1dsOVFRVlJJUGdvZ0lEeEtVMFpZWDFCQlZFZytMMmh2YldVdmMyTnZiM1I2THk1amIyNW1hV2N2VWtWQlVF +VlNMMFZtClptVmpkSE04TDBwVFJsaGZVRUZVU0Q0S0lEd3ZSVzVuYVc1bFUyVjBkR2x1WjNNK0Nnb2dQQ0V0TFNCUVlYSmhiV1YwY21saklFVnhkV0ZzYVhw +bGNpQjRNVFlnVTNSbGNtVnZJQzB0UGdvZ1BGQnNkV2RwYmo0SwpJQ0E4U1c1bWJ6NEtJQ0FnUEZSNWNHVStWbE5VTWp3dlZIbHdaVDRLSUNBZ1BFNWhiV1Ur +VUdGeVlXMWxkSEpwWXlCRmNYVmhiR2w2WlhJZ2VERTJJRk4wWlhKbGJ6d3ZUbUZ0WlQ0S0lDQWdQRUpwYm1GeWVUNHYKZFhOeUwyeHBZaTkyYzNRdmJITndM +WEJzZFdkcGJuTXVkbk4wTDNCaGNtRXRaWEYxWVd4cGVtVnlMWGd4TmkxemRHVnlaVzh1YzI4OEwwSnBibUZ5ZVQ0S0lDQWdQRlZ1YVhGMVpVbEVQakUyTXpB +NE9Ea3pNekE4CkwxVnVhWEYxWlVsRVBnb2dJRHd2U1c1bWJ6NEtDaUFnUEVSaGRHRStDaUFnSUR4QlkzUnBkbVUrV1dWelBDOUJZM1JwZG1VK0NpQWdJRHhE +YjI1MGNtOXNRMmhoYm01bGJENHhQQzlEYjI1MGNtOXNRMmhoYm01bApiRDRLSUNBZ1BFOXdkR2x2Ym5NK01IZzVQQzlQY0hScGIyNXpQZ29LSUNBZ1BFTm9k +VzVyUGdwUk1rNTFVM2RCUVVOcE1VZFJhMDV2UVVGQlFVRlhSVEZhV0VsQlFVRjFORUZCUVVGQlFVRkJRVUZCUVVGQlFVRkIKUVVGQlFVRkJRVUZCUVVGQlFV +RkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUVLUVVGQlFVRkJRVUZC +UVVGQlFVRkJRVUZCClFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJR +VUZCUVVGQlFVRkJRVUZCUVVGQlFVcHNWWGhVVlVaVlFVRkJiVVpCUVVGTQpkVVY0VkZWR1ZVRkJRVUZNQ2xsdWJIZFpXRTU2UVVGQlFVRkJRVUZCUVVGS1dq +RTVjR0puUVM5blFVRkJRVUZCUVVOdFpHWmlNMVl3UVVRNFVEbFpVVUZCUVVGS1lsYzVhMXBSUVVGQlFVRkJRVUZCUVVSSFVteFoKTTBwb1lsaEJRVUZCUVVG +QlFVRkJRVUZ3ZVZwWFJtcGtRVUVyVkUxNlRrRkJRVUZEYms1dllWZGFNQXBCUkN0QlFVRkJRVUZCUVVwbGJUbDJZbEZCT0RWUmVHWkJRVUZCUTFkYWVscFhk +MEZCUVVGQlFVRkJRVUZCCmNIaGtWMFoxWkVGQlFVRkJRVUZCUVVGQlJFZHNkV016UW1aaFYxRkJkalJCUVVGQlFVRkJRWFJ3WW01T2QxZ3pTVUZRTkVGQlFV +RkJRVUZCZUhCaWJrNTNXREk1ZFVGQlFVRUtRVUZCUVVGQlFVZGpNbFoxV2tGQgpRVUZCUVVGRFNFcHNaRWhXZVdKblFVRkJRVUZCUTIxc2JWcFdPWE5CUkN0 +QlFVRkJRVUZCUVV0aU1scHNXREozUVZBMFFVRkJRVUZCUVVGd2VWcHRWbVppUVVFdlowRkJRVUZCUVVGRGJXeHRXbFk1ZVVGRUswRkIKUVVGQlFVRkJTMkl5 +V214WU0wbEJDbEEwUVVGQlFVRkJRVUZ3ZVZwdFZtWmpaMEV2WjBGQlFVRkJRVUZEUjBwb1lrRkJRVUZCUVVGQlFVRkJRMWRhZVdOWVRVRkJRVUZCUVVGQlFV +RkJiRzFrUmpoM1FVVkJRVUZCClFVRkJRVUZLV20weFprMUJRVUZCUVVGQlFVRkJRVU5JVG1aTlFVRkJRVUZCUVVGQlFVRkRXR2g2V0hwQlFRcEJRVUZCUVVG +QlFVRkJiRFJpVmpoM1FVRkJRVUZCUVVGQlFVRkpXbXc0ZDBGRlN6QkJRVUZCUVVGQgpTV1F4T0hkQlJVTkJRVUZCUVVGQlFVbGFNVGgzUVVRclFVRkJRVUZC +UVVGSlkxWTRkMEZFT0RBdlpsRkJRVUZCUzJGSVZteFlla0ZCUVVGQlFVRkJRVUZCUVd4dFpFWTRlRUZFSzBFS1FVRkJRVUZCUVVwYWJURm0KVFZGQlFVRkJR +VUZCUVVGQlEwaE9aazFSUVVGQlFVRkJRVUZCUVVOWWFIcFlla1ZCUVVGQlFVRkJRVUZCUVd3MFlsWTRlRUZCUVVGQlFVRkJRVUZCU1Zwc09IaEJSVlZqVVVG +QlFVRkJRVWxrTVRoNFFVVkRRVUZCClFVRkJRVUZKV2pFNGVFRkVPV3RMVUZsQkNrRkJRVWxqVmpoNFFVUXJRVUZCUVVGQlFVRkxZVWhXYkZoNlJVRlFXVUZC +UVVGQlFVRkJiRzFrUmpoNVFVRkJRVUZCUVVGQlFVRktXbTB4WmsxblFVRkJRVUZCUVVGQgpRVU5JVG1aTlowRkJRVUZCUVVGQlFVRkRXR2g2V0hwSlFVRkJR +VUZCUVVGQlFVRnNOR0pXT0hsQlFVRkJRVUZCUVFwQlFVRkpXbXc0ZVVGRlRqWkJRVUZCUVVGQlNXUXhPSGxCUlVOQlFVRkJRVUZCUVVsYU1UaDUKUVVRclFV +RkJRVUZCUVVGSlkxWTRlVUZCUVVGQlFVRkJRVUZCUzJGSVZteFlla2xCVUdkQlFVRkJRVUZCUVd4dFpFWTRla0ZCUVVGQlFVRkJRVUZCU2xwdE1XWk5kMEZC +UVVGQlFVRkJRVUVLUTBoT1prMTNRVUZCClFVRkJRVUZCUVVOWWFIcFllazFCUVVGQlFVRkJRVUZCUVd3MFlsWTRla0ZCUVVGQlFVRkJRVUZCU1Zwc09IcEJS +VkJKUVVGQlFVRkJRVWxrTVRoNlFVVkRRVUZCUVVGQlFVRkpXakU0ZWtGRUswRkJRVUZCUVVGQgpTV05XT0hwQlFVRkJRVUZCUVVGQlFVdGhTRlpzQ2xoNlRV +RlFhMEZCUVVGQlFVRkJiRzFrUmpnd1FVRkJRVUZCUVVGQlFVRktXbTB4Wms1QlFVRkJRVUZCUVVGQlFVTklUbVpPUVVGQlFVRkJRVUZCUVVGRFdHaDYKV0hw +UlFVRkJRVUZCUVVGQlFVRnNOR0pXT0RCQlFVRkJRVUZCUVVGQlFVbGFiRGd3UVVWUlpHZEJRVUZCUVVGSlpERTRNQXBCUlVOQlFVRkJRVUZCUVVsYU1UZ3dR +VVFyUVVGQlFVRkJRVUZKWTFZNE1FRkJRVUZCClFVRkJRVUZCUzJGSVZteFllbEZCVUc5QlFVRkJRVUZCUVd4dFpFWTRNVUZCUVVGQlFVRkJRVUZCU2xwdE1X +Wk9VVUZCUVVGQlFVRkJRVUZEU0U1bVRsRkJRVUZCUVVGQlFVRkJRMWhvZWxoNlZVRUtRVUZCUVVGQgpRVUZCUVd3MFlsWTRNVUZCUVVGQlFVRkJRVUZCU1Zw +c09ERkJSVkkyUVVGQlFVRkJRVWxrTVRneFFVVkRRVUZCUVVGQlFVRkpXakU0TVVGRUswRkJRVUZCUVVGQlNXTldPREZCUVVGQlFVRkJRVUZCUVV0aFNGWnMK +V0hwVlFWQnhRVUZCUVVGQlFVRnNiV1JHT0RKQlFVRkJDa0ZCUVVGQlFVRktXbTB4Wms1blFVRkJRVUZCUVVGQlFVTklUbVpPWjBGQlFVRkJRVUZCUVVGRFdH +aDZXSHBaUVVGQlFVRkJRVUZCUVVGc05HSldPREpCClFVRkJRVUZCUVVGQlFVbGFiRGd5UVVWVVNVRkJRVUZCUVVGSlpERTRNa0ZGUTBGQlFVRkJRVUZCU1Zv +eE9ESkJSQ3RCUVVGQlFRcEJRVUZKWTFZNE1rRkJRVUZCUVVGQlFVRkJTMkZJVm14WWVsbEJVSE5CUVVGQgpRVUZCUVd4dFpFWTRNMEZCUVVGQlFVRkJRVUZC +U2xwdE1XWk9kMEZCUVVGQlFVRkJRVUZEU0U1bVRuZEJRVUZCUVVGQlFVRkJRMWhvZWxoNlkwRkJRVUZCUVVGQlFVRkJiRFJpVmpnelFVRkJRVUZCUVVFS1FV +RkIKU1Zwc09ETkJSVlZqVVVGQlFVRkJRVWxrTVRnelFVVkRRVUZCUVVGQlFVRkpXakU0TTBGRUswRkJRVUZCUVVGQlNXTldPRE5CUVVGQlFVRkJRVUZCUVV0 +aFNGWnNXSHBqUVZCMVFVRkJRVUZCUVVGc2JXUkdPRFJCClFVRkJRVUZCUVVGQlFVcGFiVEZtVDBGQlFVRkJRVUZCUVVGQkNrTklUbVpQUVVGQlFVRkJRVUZC +UVVGRFdHaDZXSHBuUVVGQlFVRkJRVUZCUVVGc05HSldPRFJCUVVGQlFVRkJRVUZCUVVsYWJEZzBRVVZXTmtGQgpRVUZCUVVGSlpERTRORUZGUTBGQlFVRkJR +VUZCU1ZveE9EUkJSQ3RCUVVGQlFVRkJRVWxqVmpnMFFVRkJRVUZCUVVGQlFVRkxZVWhXYkFwWWVtZEJVSGRCUVVGQlFVRkJRV3h0WkVZNE5VRkJRVUZCUVVG +QlFVRkIKU2xwdE1XWlBVVUZCUVVGQlFVRkJRVUZEU0U1bVQxRkJRVUZCUVVGQlFVRkJRMWhvZWxoNmEwRkJRVUZCUVVGQlFVRkJiRFJpVmpnMVFVRkJRVUZC +UVVGQlFVRkpXbXc0TlVGRldFVTBRVUZCUVVGQlNXUXhPRFVLClFVVkRRVUZCUVVGQlFVRkpXakU0TlVGRUswRkJRVUZCUVVGQlNXTldPRFZCUVVGQlFVRkJR +VUZCUVV0aFNGWnNXSHByUVZCNFFVRkJRVUZCUVVGd2JXUkdPSGhOUVVGQlFVRkJRVUZCUVVGRGJWcDBXSHBGZDBGQgpRVUZCUVVGQlFVRkJTbU14T0hoTlFV +RkJRVUZCUVVGQlFVRkRibWg2Q2xoNlJYZEJRVUZCUVVGQlFVRkJRVXRsUnpGbVRWUkJRVUZCUVVGQlFVRkJRVUZzYlZoNlJYZEJSVmxqVVVGQlFVRkJRVXBr +TVRoNFRVRkMKUVdkQlFVRkJRVUZCUTFka1prMVVRVUZRTkVGQlFVRkJRVUZCYkhoWWVrVjNRVUZCUVVGQlFVRkJRVUZNWVVoV2JGaDZSWGRCUkRoblFVRkJR +UXBCUVVGTFdtNVNaazFVUlVGQlFVRkJRVUZCUVVGQmNHMWlWamg0ClRWRkJRVUZCUVVGQlFVRkJRMWhPWmsxVVJVRkJRVUZCUVVGQlFVRkJjRFJqTVRoNFRW +RkJRVUZCUVVGQlFVRkJRMjVvZEZoNlJYaEJRVUZCUVVGQlFVRkJRVXBhYkRoNFRWRkNSMlZuUVVGQlFVRkJRMWhrWmsxVQpSVUVLVVVsQlFVRkJRVUZCUVd4 +dVdIcEZlRUZFSzBGQlFVRkJRVUZCU21OV09IaE5VVUZCUVVGQlFVRkJRVUZETW1neFdsWTRlRTFSUVM5TlFVRkJRVUZCUVVOdFdqQllla1Y1UVVGQlFVRkJR +VUZCUVVGTFdtMHgKWmsxVVNVRkJRVUZCUVVGQlFVRkJiSHBZZWtWNVFVRkJRVUZCUVVGQlFVRkxDbVZJVG1aTlZFbEJRVUZCUVVGQlFVRkJRWEEwWWxZNGVF +MW5RVUZCUVVGQlFVRkJRVU5YV21aTlZFbEJVWE5uUVVGQlFVRkJRV3d6CldIcEZlVUZGUTBGQlFVRkJRVUZCU2xveE9IaE5aMEV2WjBGQlFVRkJRVUZEV0Va +bVRWUkpRVUZCUVVGQlFVRkJRVUYwYjJSWFZtWk5WRWxCVURCQlFRcEJRVUZCUVVGd2JXUkdPSGhOZDBGQlFVRkJRVUZCUVVGRApiVnAwV0hwRmVrRkJRVUZC +UVVGQlFVRkJTbU14T0hoTmQwRkJRVUZCUVVGQlFVRkRibWg2V0hwRmVrRkJRVUZCUVVGQlFVRkJTMlZITVdaTlZFMUJRVUZCUVVGQlFVRkJRV3h0V0hwRmVr +RkZURWxCUVVGQlFVRkIKU21ReE9IZ0tUWGRDUVdkQlFVRkJRVUZCUTFka1prMVVUVUZRTkVGQlFVRkJRVUZCYkhoWWVrVjZRVUZCUVVGQlFVRkJRVUZNWVVo +V2JGaDZSWHBCUkRsUlFVRkJRVUZCUVV0YWJsSm1UVlJSUVVGQlFVRkJRVUZCClFVRndiV0pXT0hoT1FVRkJRVUZCUVVGQlFVRkRXRTVtVFZSUlFVRkJRVUZC +UVVGQkNrRkJjRFJqTVRoNFRrRkJRVUZCUVVGQlFVRkJRMjVvZEZoNlJUQkJRVUZCUVVGQlFVRkJRVXBhYkRoNFRrRkNRM2xCUVVGQgpRVUZCUTFoa1prMVVV +VUZSU1VGQlFVRkJRVUZCYkc1WWVrVXdRVVFyUVVGQlFVRkJRVUZLWTFZNGVFNUJRVUZCUVVGQlFVRkJRVU15YURGYVZqaDRUa0ZCTHdwWlFVRkJRVUZCUVVO +dFdqQllla1V4UVVGQlFVRkIKUVVGQlFVRkxXbTB4WmsxVVZVRkJRVUZCUVVGQlFVRkJiSHBZZWtVeFFVRkJRVUZCUVVGQlFVRkxaVWhPWmsxVVZVRkJRVUZC +UVVGQlFVRkJjRFJpVmpoNFRsRkJRVUZCUVVGQlFVRkJRMWRhWmsxVVZVRlJjMmRCClFVRkJRVUZCYkRNS1dIcEZNVUZGUTBGQlFVRkJRVUZCU2xveE9IaE9V +VUV2WjBGQlFVRkJRVUZEV0VabVRWUlZRVUZCUVVGQlFVRkJRVUYwYjJSWFZtWk5WRlZCVUROQlFVRkJRVUZCUTJkb1kwaEtiR015VmpCWQpNMDR3V1ZoU2JF +RkJRVUZCUVVWQlFVRkJRVkZZU25SWlUwSkVXbGMxTUZwWVNXZFJXRlpyQ21GWE9FRUtJQ0FnUEM5RGFIVnVhejRLSUNBOEwwUmhkR0UrQ2lBOEwxQnNkV2Rw +Ymo0S1BDOURRVkpNUVMxUVVrOUsKUlVOVVBnb0EKICAgPC9DaHVuaz4KICA8L0RhdGE+CiA8L1BsdWdpbj4KCiA8IS0tIENhcmxhLVJhY2sgLS0+CiA8UGx1 +Z2luPgogIDxJbmZvPgogICA8VHlwZT5WU1QyPC9UeXBlPgogICA8TmFtZT5STCBSUjwvTmFtZT4KICAgPEJpbmFyeT4vbGliL3ZzdC9jYXJsYS52c3QvQ2Fy +bGFSYWNrLnNvPC9CaW5hcnk+CiAgIDxVbmlxdWVJRD4xMTMxNTcyMzIzPC9VbmlxdWVJRD4KICA8L0luZm8+CgogIDxEYXRhPgogICA8QWN0aXZlPlllczwv +QWN0aXZlPgogICA8Q29udHJvbENoYW5uZWw+MTwvQ29udHJvbENoYW5uZWw+CiAgIDxPcHRpb25zPjB4M2Y5PC9PcHRpb25zPgoKICAgPENodW5rPgpQRDk0 +Yld3Z2RtVnljMmx2Ymowbk1TNHdKeUJsYm1OdlpHbHVaejBuVlZSR0xUZ25QejRLUENGRVQwTlVXVkJGSUVOQlVreEJMVkJTVDBwRlExUStDanhEUVZKTVFT +MVFVazlLUlVOVUlGWkZVbE5KVDA0OUp6SXUKTlNjK0NpQThSVzVuYVc1bFUyVjBkR2x1WjNNK0NpQWdQRVp2Y21ObFUzUmxjbVZ2UG1aaGJITmxQQzlHYjNK +alpWTjBaWEpsYno0S0lDQThVSEpsWm1WeVVHeDFaMmx1UW5KcFpHZGxjejVtWVd4elpUd3ZVSEpsClptVnlVR3gxWjJsdVFuSnBaR2RsY3o0S0lDQThVSEps +Wm1WeVZXbENjbWxrWjJWelBuUnlkV1U4TDFCeVpXWmxjbFZwUW5KcFpHZGxjejRLSUNBOFZVbHpRV3gzWVhselQyNVViM0ErWm1Gc2MyVThMMVZKYzBGcwpk +MkY1YzA5dVZHOXdQZ29nSUR4TllYaFFZWEpoYldWMFpYSnpQakl3TUR3dlRXRjRVR0Z5WVcxbGRHVnljejRLSUNBOFZVbENjbWxrWjJWelZHbHRaVzkxZEQ0 +ME1EQXdQQzlWU1VKeWFXUm5aWE5VYVcxbGIzVjAKUGdvZ0lEeE1RVVJUVUVGZlVFRlVTRDR2YUc5dFpTOXpZMjl2ZEhvdkxteGhaSE53WVRvdmRYTnlMMnhw +WWk5c1lXUnpjR0U2TDNWemNpOXNiMk5oYkM5c2FXSXZiR0ZrYzNCaFBDOU1RVVJUVUVGZlVFRlVTRDRLCklDQThSRk5UU1Y5UVFWUklQaTlvYjIxbEwzTmpi +MjkwZWk4dVpITnphVG92ZFhOeUwyeHBZaTlrYzNOcE9pOTFjM0l2Ykc5allXd3ZiR2xpTDJSemMyazhMMFJUVTBsZlVFRlVTRDRLSUNBOFRGWXlYMUJCVkVn +KwpMMmh2YldVdmMyTnZiM1I2THk1c2RqSTZMM1Z6Y2k5c2FXSXZiSFl5T2k5MWMzSXZiRzlqWVd3dmJHbGlMMngyTWp3dlRGWXlYMUJCVkVnK0NpQWdQRlpU +VkRKZlVFRlVTRDR2YUc5dFpTOXpZMjl2ZEhvdkxuWnoKZERvdmRYTnlMMnhwWWk5c2VIWnpkRG92ZFhOeUwyeHBZaTkyYzNRNkwzVnpjaTlzYjJOaGJDOXNh +V0l2YkhoMmMzUTZMM1Z6Y2k5c2IyTmhiQzlzYVdJdmRuTjBMMmh2YldVdmMyTnZiM1I2THk1c2VIWnpkRG92CmJHbGlMM1p6ZEM5allYSnNZUzUyYzNROEwx +WlRWREpmVUVGVVNENEtJQ0E4VmxOVU0xOVFRVlJJUGk5b2IyMWxMM05qYjI5MGVpOHVkbk4wTXpvdmRYTnlMMnhwWWk5MmMzUXpPaTkxYzNJdmJHOWpZV3d2 +YkdsaQpMM1p6ZERNOEwxWlRWRE5mVUVGVVNENEtJQ0E4VTBZeVgxQkJWRWcrTDJodmJXVXZjMk52YjNSNkx5NXpiM1Z1WkhNdmMyWXlPaTlvYjIxbEwzTmpi +MjkwZWk4dWMyOTFibVJ6TDNObU16b3ZkWE55TDNOb1lYSmwKTDNOdmRXNWtabTl1ZEhNNkwzVnpjaTl6YUdGeVpTOXpiM1Z1WkhNdmMyWXlPaTkxYzNJdmMy +aGhjbVV2YzI5MWJtUnpMM05tTXp3dlUwWXlYMUJCVkVnK0NpQWdQRk5HV2w5UVFWUklQaTlvYjIxbEwzTmpiMjkwCmVpOHVjMjkxYm1SekwzTm1lam92ZFhO +eUwzTm9ZWEpsTDNOdmRXNWtjeTl6Wm5vOEwxTkdXbDlRUVZSSVBnb2dJRHhLVTBaWVgxQkJWRWcrTDJodmJXVXZjMk52YjNSNkx5NWpiMjVtYVdjdlVrVkJV +RVZTTDBWbQpabVZqZEhNOEwwcFRSbGhmVUVGVVNENEtJRHd2Ulc1bmFXNWxVMlYwZEdsdVozTStDZ29nUENFdExTQlFZWEpoYldWMGNtbGpJRVZ4ZFdGc2FY +cGxjaUI0TVRZZ1UzUmxjbVZ2SUMwdFBnb2dQRkJzZFdkcGJqNEsKSUNBOFNXNW1iejRLSUNBZ1BGUjVjR1UrVmxOVU1qd3ZWSGx3WlQ0S0lDQWdQRTVoYldV +K1VHRnlZVzFsZEhKcFl5QkZjWFZoYkdsNlpYSWdlREUySUZOMFpYSmxiend2VG1GdFpUNEtJQ0FnUEVKcGJtRnllVDR2CmRYTnlMMnhwWWk5MmMzUXZiSE53 +TFhCc2RXZHBibk11ZG5OMEwzQmhjbUV0WlhGMVlXeHBlbVZ5TFhneE5pMXpkR1Z5Wlc4dWMyODhMMEpwYm1GeWVUNEtJQ0FnUEZWdWFYRjFaVWxFUGpFMk16 +QTRPRGt6TXpBOApMMVZ1YVhGMVpVbEVQZ29nSUR3dlNXNW1iejRLQ2lBZ1BFUmhkR0UrQ2lBZ0lEeEJZM1JwZG1VK1dXVnpQQzlCWTNScGRtVStDaUFnSUR4 +RGIyNTBjbTlzUTJoaGJtNWxiRDR4UEM5RGIyNTBjbTlzUTJoaGJtNWwKYkQ0S0lDQWdQRTl3ZEdsdmJuTStNSGc1UEM5UGNIUnBiMjV6UGdvS0lDQWdQRU5v +ZFc1clBncFJNazUxVTNkQlFVTnBkRWRSYTA1dlFVRkJRVUZYUlRGYVdFbEJRVUYxTkVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCClFVRkJRVUZCUVVGQlFVRkJR +VUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVFS1FVRkJRVUZCUVVG +QlFVRkJRVUZCUVVGQgpRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZCUVVGQlFVRkJRVUZC +UVVGQlFVRkJRVUZCUVVGQlFVRkJRVXByTUhoVVZVWlZRVUZCYlVSQlFVRk0KZFVWNFZGVkdWVUZCUVVGTUNsbHViSGRaV0U1NlFVRkJRVUZCUVVGQlFVRktX +akU1Y0dKblFTOW5RVUZCUVVGQlFVTnRaR1ppTTFZd1FVUTRNVkJFV1VGQlFVRktZbGM1YTFwUlFVRkJRVUZCUVVGQlFVUkhVbXhaCk0wcG9ZbGhCUVVGQlFV +RkJRVUZCUVVGd2VWcFhSbXBrUVVFclZFMTZUa0ZCUVVGRGJrNXZZVmRhTUFwQlJDdEJRVUZCUVVGQlFVcGxiVGwyWWxGQk9EVlJlR1pCUVVGQlExZGFlbHBY +ZDBGQlFVRkJRVUZCUVVGQgpjSGhrVjBaMVpFRkJRVUZCUVVGQlFVRkJSRWRzZFdNelFtWmhWMUZCZGpSQlFVRkJRVUZCUVhSd1ltNU9kMWd6U1VGUU5FRkJR +VUZCUVVGQmVIQmliazUzV0RJNWRVRkJRVUVLUVVGQlFVRkJRVWRqTWxaMVdrRkIKUVVGQlFVRkRTRXBzWkVoV2VXSm5RVUZCUVVGQlEyMXNiVnBXT1hOQlJD +dEJRVUZCUVVGQlFVdGlNbHBzV0RKM1FWQTBRVUZCUVVGQlFVRndlVnB0Vm1aaVFVRXZaMEZCUVVGQlFVRkRiV3h0V2xZNWVVRkVLMEZCClFVRkJRVUZCUzJJ +eVdteFlNMGxCQ2xBMFFVRkJRVUZCUVVGd2VWcHRWbVpqWjBFdlowRkJRVUZCUVVGRFIwcG9Za0ZCUVVGQlFVRkJRVUZCUTFkYWVXTllUVUZCUVVGQlFVRkJR +VUZCYkcxa1JqaDNRVVZCUVVGQgpRVUZCUVVGS1dtMHhaazFCUVVGQlFVRkJRVUZCUVVOSVRtWk5RVUZCUVVGQlFVRkJRVUZEV0doNldIcEJRUXBCUVVGQlFV +RkJRVUZCYkRSaVZqaDNRVUZCUVVGQlFVRkJRVUZKV213NGQwRkZUVTFCUVVGQlFVRkIKU1dReE9IZEJSVU5CUVVGQlFVRkJRVWxhTVRoM1FVUXJRVUZCUVVG +QlFVRkpZMVk0ZDBGRU9EQXZabEZCUVVGQlMyRklWbXhZZWtGQlFVRkJRVUZCUVVGQlFXeHRaRVk0ZUVGRUswRUtRVUZCUVVGQlFVcGFiVEZtClRWRkJRVUZC +UVVGQlFVRkJRMGhPWmsxUlFVRkJRVUZCUVVGQlFVTllhSHBZZWtWQlFVRkJRVUZCUVVGQlFXdzBZbFk0ZUVGQlFVRkJRVUZCUVVGQlNWcHNPSGhCUlZKMFow +RkJRVUZCUVVsa01UaDRRVVZEUVVGQgpRVUZCUVVGSldqRTRlRUZFS3pCNmFIZEJDa0ZCUVVsalZqaDRRVVFyWjBGQlFVRkJRVUZMWVVoV2JGaDZSVUZRV1VG +QlFVRkJRVUZCYkcxa1JqaDVRVVFyUVVGQlFVRkJRVUZLV20weFprMW5RVUZCUVVGQlFVRkIKUVVOSVRtWk5aMEZCUVVGQlFVRkJRVUZEV0doNldIcEpRVUZC +UVVGQlFVRkJRVUZzTkdKV09IbEJRVUZCUVVGQlFRcEJRVUZKV213NGVVRkZWVzkzUVVGQlFVRkJTV1F4T0hsQlJVTkJRVUZCUVVGQlFVbGFNVGg1ClFVUTVU +RmRVV1VGQlFVRkpZMVk0ZVVGRUswRkJRVUZCUVVGQlMyRklWbXhZZWtsQlVHZEJRVUZCUVVGQlFXeHRaRVk0ZWtGRUswRkJRVUZCUVVGQlNscHRNV1pOZDBG +QlFVRkJRVUZCUVVFS1EwaE9aazEzUVVGQgpRVUZCUVVGQlFVTllhSHBZZWsxQlFVRkJRVUZCUVVGQlFXdzBZbFk0ZWtGQlFVRkJRVUZCUVVGQlNWcHNPSHBC +UlZoVlowRkJRVUZCUVVsa01UaDZRVVZEUVVGQlFVRkJRVUZKV2pFNGVrRkVPRkE1V1ZGQlFVRkIKU1dOV09IcEJSVUZCUVVGQlFVRkJRVXRoU0Zac0NsaDZU +VUZRYTBGQlFVRkJRVUZCYkcxa1JqZ3dRVVZDUVVGQlFVRkJRVUZLV20weFprNUJRVUZCUVVGQlFVRkJRVU5JVG1aT1FVRkJRVUZCUVVGQlFVRkRXR2g2CldI +cFJRVUZCUVVGQlFVRkJRVUZzTkdKV09EQkJRVUZCUVVGQlFVRkJRVWxhYkRnd1FVVlpUVzlCUVVGQlFVRkpaREU0TUFwQlJVTkJRVUZCUVVGQlFVbGFNVGd3 +UVVRNE1WQkVXVUZCUVVGSlkxWTRNRUZFT0hwTgplazFCUVVGQlMyRklWbXhZZWxGQlVHOUJRVUZCUVVGQlFXeHRaRVk0TVVGQlFVRkJRVUZCUVVGQlNscHRN +V1pPVVVGQlFVRkJRVUZCUVVGRFNFNW1UbEZCUVVGQlFVRkJRVUZCUTFob2VsaDZWVUVLUVVGQlFVRkIKUVVGQlFXdzBZbFk0TVVGQlFVRkJRVUZCUVVGQlNW +cHNPREZCUlUxblFVRkJRVUZCUVVsa01UZ3hRVVZEUVVGQlFVRkJRVUZKV2pFNE1VRkVLMEZCUVVGQlFVRkJTV05XT0RGQlFVRkJRVUZCUVVGQlFVdGhTRlpz +CldIcFZRVkJ4UVVGQlFVRkJRVUZzYldSR09ESkJRVUZCQ2tGQlFVRkJRVUZLV20weFprNW5RVUZCUVVGQlFVRkJRVU5JVG1aT1owRkJRVUZCUVVGQlFVRkRX +R2g2V0hwWlFVRkJRVUZCUVVGQlFVRnNOR0pXT0RKQgpRVUZCUVVGQlFVRkJRVWxhYkRneVFVVk9Oa0ZCUVVGQlFVRkpaREU0TWtGRlEwRkJRVUZCUVVGQlNW +b3hPREpCUkN0QlFVRkJRUXBCUVVGSlkxWTRNa0ZCUVVGQlFVRkJRVUZCUzJGSVZteFllbGxCVUhOQlFVRkIKUVVGQlFXeHRaRVk0TTBGQlFVRkJRVUZCUVVG +QlNscHRNV1pPZDBGQlFVRkJRVUZCUVVGRFNFNW1UbmRCUVVGQlFVRkJRVUZCUTFob2VsaDZZMEZCUVVGQlFVRkJRVUZCYkRSaVZqZ3pRVUZCUVVGQlFVRUtR +VUZCClNWcHNPRE5CUlZCSlFVRkJRVUZCUVVsa01UZ3pRVVZEUVVGQlFVRkJRVUZKV2pFNE0wRkVLMEZCUVVGQlFVRkJTV05XT0ROQlFVRkJRVUZCUVVGQlFV +dGhTRlpzV0hwalFWQjFRVUZCUVVGQlFVRnNiV1JHT0RSQgpRVUZCUVVGQlFVRkJRVXBhYlRGbVQwRkJRVUZCUVVGQlFVRkJDa05JVG1aUFFVRkJRVUZCUVVG +QlFVRkRXR2g2V0hwblFVRkJRVUZCUVVGQlFVRnNOR0pXT0RSQlFVRkJRVUZCUVVGQlFVbGFiRGcwUVVWUlpHZEIKUVVGQlFVRkpaREU0TkVGRlEwRkJRVUZC +UVVGQlNWb3hPRFJCUkN0QlFVRkJRVUZCUVVsalZqZzBRVUZCUVVGQlFVRkJRVUZMWVVoV2JBcFllbWRCVUhkQlFVRkJRVUZCUVd4dFpFWTROVUZCUVVGQlFV +RkJRVUZCClNscHRNV1pQVVVGQlFVRkJRVUZCUVVGRFNFNW1UMUZCUVVGQlFVRkJRVUZCUTFob2VsaDZhMEZCUVVGQlFVRkJRVUZCYkRSaVZqZzFRVUZCUVVG +QlFVRkJRVUZKV213NE5VRkZValpCUVVGQlFVRkJTV1F4T0RVSwpRVVZEUVVGQlFVRkJRVUZKV2pFNE5VRkVLMEZCUVVGQlFVRkJTV05XT0RWQlFVRkJRVUZC +UVVGQlFVdGhTRlpzV0hwclFWQjRRVUZCUVVGQlFVRndiV1JHT0hoTlFVRkJRVUZCUVVGQlFVRkRiVnAwV0hwRmQwRkIKUVVGQlFVRkJRVUZCU21NeE9IaE5R +VUZCUVVGQlFVRkJRVUZEYm1oNkNsaDZSWGRCUVVGQlFVRkJRVUZCUVV0bFJ6Rm1UVlJCUVVGQlFVRkJRVUZCUVVGc2JWaDZSWGRCUlZSSlFVRkJRVUZCUVVw +a01UaDRUVUZDClFXZEJRVUZCUVVGQlExZGtaazFVUVVGUU5FRkJRVUZCUVVGQmJIaFlla1YzUVVGQlFVRkJRVUZCUVVGTVlVaFdiRmg2UlhkQlJEaG5RVUZC +UVFwQlFVRkxXbTVTWmsxVVJVRkJRVUZCUVVGQlFVRkJjRzFpVmpoNApUVkZCUVVGQlFVRkJRVUZCUTFoT1prMVVSVUZCUVVGQlFVRkJRVUZCY0RSak1UaDRU +VkZCUVVGQlFVRkJRVUZCUTI1b2RGaDZSWGhCUVVGQlFVRkJRVUZCUVVwYWJEaDRUVkZDUmtoRlFVRkJRVUZCUTFoa1prMVUKUlVFS1VVbEJRVUZCUVVGQlFX +eHVXSHBGZUVGRUswRkJRVUZCUVVGQlNtTldPSGhOVVVGQlFVRkJRVUZCUVVGRE1tZ3hXbFk0ZUUxUlFTOU5RVUZCUVVGQlFVTnRXakJZZWtWNVFVRkJRVUZC +UVVGQlFVRkxXbTB4ClprMVVTVUZCUVVGQlFVRkJRVUZCYkhwWWVrVjVRVUZCUVVGQlFVRkJRVUZMQ21WSVRtWk5WRWxCUVVGQlFVRkJRVUZCUVhBMFlsWTRl +RTFuUVVGQlFVRkJRVUZCUVVOWFdtWk5WRWxCVWxodlFVRkJRVUZCUVd3egpXSHBGZVVGRlEwRkJRVUZCUVVGQlNsb3hPSGhOWjBFdlowRkJRVUZCUVVGRFdF +Wm1UVlJKUVVGQlFVRkJRVUZCUVVGMGIyUlhWbVpOVkVsQlVEQkJRUXBCUVVGQlFVRndiV1JHT0hoTmQwRkJRVUZCUVVGQlFVRkQKYlZwMFdIcEZla0ZCUVVG +QlFVRkJRVUZCU21NeE9IaE5kMEZCUVVGQlFVRkJRVUZEYm1oNldIcEZla0ZCUVVGQlFVRkJRVUZCUzJWSE1XWk5WRTFCUVVGQlFVRkJRVUZCUVd4dFdIcEZl +a0ZGV0VVMFFVRkJRVUZCClNtUXhPSGdLVFhkQ1FXZEJRVUZCUVVGQlExZGtaazFVVFVGUU5FRkJRVUZCUVVGQmJIaFlla1Y2UVVGQlFVRkJRVUZCUVVGTVlV +aFdiRmg2UlhwQlJEbFJRVUZCUVVGQlFVdGFibEptVFZSUlFVRkJRVUZCUVVGQgpRVUZ3YldKV09IaE9RVUZCUVVGQlFVRkJRVUZEV0U1bVRWUlJRVUZCUVVG +QlFVRkJDa0ZCY0RSak1UaDRUa0ZCUVVGQlFVRkJRVUZCUTI1b2RGaDZSVEJCUVVGQlFVRkJRVUZCUVVwYWJEaDRUa0ZDUjBoRlFVRkIKUVVGQlExaGtaazFV +VVVGUlNVRkJRVUZCUVVGQmJHNVlla1V3UVVRclFVRkJRVUZCUVVGS1kxWTRlRTVCUVVGQlFVRkJRVUZCUVVNeWFERmFWamg0VGtGQkx3cFpRVUZCUVVGQlFV +TnRXakJZZWtVeFFVRkJRVUZCClFVRkJRVUZMV20weFprMVVWVUZCUVVGQlFVRkJRVUZCYkhwWWVrVXhRVUZCUVVGQlFVRkJRVUZMWlVoT1prMVVWVUZCUVVG +QlFVRkJRVUZCY0RSaVZqaDRUbEZCUVVGQlFVRkJRVUZCUTFkYVprMVVWVUZTYm05QgpRVUZCUVVGQmJETUtXSHBGTVVGRlEwRkJRVUZCUVVGQlNsb3hPSGhP +VVVFdlowRkJRVUZCUVVGRFdFWm1UVlJWUVVGQlFVRkJRVUZCUVVGMGIyUlhWbVpOVkZWQlVETkJRVUZCUVVGQlExbG9ZMGhLYkdNeVZqQlkKTTA0d1dWaFNi +RUZCUVVGQlFVMUJRVUZCUVZGWVNuUlpVMEpUV2xkR2VVbEZSakZhUjJ4MkNrRkJQVDBLSUNBZ1BDOURhSFZ1YXo0S0lDQThMMFJoZEdFK0NpQThMMUJzZFdk +cGJqNEtQQzlEUVZKTVFTMVFVazlLClJVTlVQZ29BCiAgIDwvQ2h1bms+CiAgPC9EYXRhPgogPC9QbHVnaW4+CgogPFBhdGNoYmF5PgogIDxDb25uZWN0aW9u +PgogICA8U291cmNlPkF1ZGlvIElucHV0OkNhcHR1cmUgMTwvU291cmNlPgogICA8VGFyZ2V0PkZMIEZSOmlucHV0XzE8L1RhcmdldD4KICA8L0Nvbm5lY3Rp +b24+CiAgPENvbm5lY3Rpb24+CiAgIDxTb3VyY2U+QXVkaW8gSW5wdXQ6Q2FwdHVyZSAyPC9Tb3VyY2U+CiAgIDxUYXJnZXQ+RkwgRlI6aW5wdXRfMjwvVGFy +Z2V0PgogIDwvQ29ubmVjdGlvbj4KICA8Q29ubmVjdGlvbj4KICAgPFNvdXJjZT5BdWRpbyBJbnB1dDpDYXB0dXJlIDM8L1NvdXJjZT4KICAgPFRhcmdldD5G +QzppbnB1dF8xPC9UYXJnZXQ+CiAgPC9Db25uZWN0aW9uPgogIDxDb25uZWN0aW9uPgogICA8U291cmNlPkF1ZGlvIElucHV0OkNhcHR1cmUgNDwvU291cmNl +PgogICA8VGFyZ2V0PlJMIFJSOmlucHV0XzE8L1RhcmdldD4KICA8L0Nvbm5lY3Rpb24+CiAgPENvbm5lY3Rpb24+CiAgIDxTb3VyY2U+QXVkaW8gSW5wdXQ6 +Q2FwdHVyZSA1PC9Tb3VyY2U+CiAgIDxUYXJnZXQ+UkwgUlI6aW5wdXRfMjwvVGFyZ2V0PgogIDwvQ29ubmVjdGlvbj4KICA8Q29ubmVjdGlvbj4KICAgPFNv +dXJjZT5GTCBGUjpvdXRwdXRfMTwvU291cmNlPgogICA8VGFyZ2V0PkF1ZGlvIE91dHB1dDpQbGF5YmFjayAxPC9UYXJnZXQ+CiAgPC9Db25uZWN0aW9uPgog +IDxDb25uZWN0aW9uPgogICA8U291cmNlPkZMIEZSOm91dHB1dF8yPC9Tb3VyY2U+CiAgIDxUYXJnZXQ+QXVkaW8gT3V0cHV0OlBsYXliYWNrIDI8L1Rhcmdl +dD4KICA8L0Nvbm5lY3Rpb24+CiAgPENvbm5lY3Rpb24+CiAgIDxTb3VyY2U+RkM6b3V0cHV0XzE8L1NvdXJjZT4KICAgPFRhcmdldD5BdWRpbyBPdXRwdXQ6 +UGxheWJhY2sgMzwvVGFyZ2V0PgogIDwvQ29ubmVjdGlvbj4KICA8Q29ubmVjdGlvbj4KICAgPFNvdXJjZT5STCBSUjpvdXRwdXRfMTwvU291cmNlPgogICA8 +VGFyZ2V0PkF1ZGlvIE91dHB1dDpQbGF5YmFjayA0PC9UYXJnZXQ+CiAgPC9Db25uZWN0aW9uPgogIDxDb25uZWN0aW9uPgogICA8U291cmNlPlJMIFJSOm91 +dHB1dF8yPC9Tb3VyY2U+CiAgIDxUYXJnZXQ+QXVkaW8gT3V0cHV0OlBsYXliYWNrIDU8L1RhcmdldD4KICA8L0Nvbm5lY3Rpb24+CiAgPFBvc2l0aW9ucz4K +ICAgPFBvc2l0aW9uIHgxPSI0NjkiIHkxPSIzNTAiIHBsdWdpbklkPSIyIj4KICAgIDxOYW1lPlJMIFJSPC9OYW1lPgogICA8L1Bvc2l0aW9uPgogICA8UG9z +aXRpb24geDE9IjQzOCIgeTE9IjI1OSIgcGx1Z2luSWQ9IjEiPgogICAgPE5hbWU+RkM8L05hbWU+CiAgIDwvUG9zaXRpb24+CiAgIDxQb3NpdGlvbiB4MT0i +NDM3IiB5MT0iMTc5IiBwbHVnaW5JZD0iMCI+CiAgICA8TmFtZT5GTCBGUjwvTmFtZT4KICAgPC9Qb3NpdGlvbj4KICAgPFBvc2l0aW9uIHgxPSIyNjEiIHkx +PSI1MTgiIHgyPSI2NTUiIHkyPSIxNjciPgogICAgPE5hbWU+QXVkaW8gT3V0cHV0PC9OYW1lPgogICA8L1Bvc2l0aW9uPgogIDwvUG9zaXRpb25zPgogPC9Q +YXRjaGJheT4KPC9DQVJMQS1QUk9KRUNUPgoA + + + + + + + UMC404HD Mono Mic:capture_MONO + Arma Reforger:input_MONO + + + UMC404HD 192k Direct UMC404HD 192k:capture_FL + UMC404HD Mono Mic:input_FL + + + Arma Reforger:output_FL + Reforger:playback_FL + + + Arma Reforger:output_FR + Reforger:playback_FR + + + Arma Reforger:output_FC + Reforger:playback_FC + + + Arma Reforger:output_LFE + Reforger:playback_LFE + + + Arma Reforger:output_RL + Reforger:playback_RL + + + Arma Reforger:output_RR + Reforger:playback_RR + + + UMC404HD Stereo:output_FL + UMC404HD 192k Direct UMC404HD 192k:playback_FL + + + UMC404HD Stereo:output_FR + UMC404HD 192k Direct UMC404HD 192k:playback_FR + + + ReforgerEQ:output_1 + UMC404HD Stereo:playback_FL + + + ReforgerEQ:output_2 + UMC404HD Stereo:playback_FR + + + ReforgerEQ:output_3 + UMC404HD Stereo:playback_FL + + + ReforgerEQ:output_3 + UMC404HD Stereo:playback_FR + + + ReforgerEQ:output_4 + UMC404HD Stereo:playback_FL + + + ReforgerEQ:output_5 + UMC404HD Stereo:playback_FR + + + UMC404HD Stereo:monitor_FL + cava:input_FL + + + UMC404HD Stereo:monitor_FL + cava-120:input_FL + + + UMC404HD Stereo:monitor_FR + cava:input_FR + + + UMC404HD Stereo:monitor_FR + cava-120:input_FR + + + UMC404HD 192k Direct UMC404HD 192k:monitor_FL + cava:input_FL + + + UMC404HD 192k Direct UMC404HD 192k:monitor_FR + cava:input_FR + + + Reforger:monitor_FL + ReforgerEQ:input_1 + + + Reforger:monitor_FR + ReforgerEQ:input_2 + + + Reforger:monitor_FC + ReforgerEQ:input_3 + + + Reforger:monitor_RL + ReforgerEQ:input_4 + + + Reforger:monitor_RR + ReforgerEQ:input_5 + + + + UMC404HD 192k Direct UMC404HD 192k + + + UMC404HD Stereo + + + Speakers + + + cava + + + Reforger + + + Midi-Bridge + + + ReforgerEQ + + + + diff --git a/reforger-surround b/reforger-surround index 5895f81..9f84f68 100755 --- a/reforger-surround +++ b/reforger-surround @@ -5,6 +5,8 @@ set -euo pipefail sink_name="${REFORGER_SURROUND_SINK_NAME:-reforger_surround_51}" sink_description="${REFORGER_SURROUND_DESCRIPTION:-Reforger Surround 5.1}" app_name="${REFORGER_SURROUND_APP_NAME:-Arma Reforger}" +steam_uri="${REFORGER_SURROUND_STEAM_URI:-steam://rungameid/1874880}" +wait_seconds="${REFORGER_SURROUND_WAIT_SECONDS:-90}" state_dir="${XDG_STATE_HOME:-$HOME/.local/state}/reforger-surround" module_id_file="${state_dir}/module-id" previous_default_sink_file="${state_dir}/previous-default-sink" @@ -14,6 +16,7 @@ usage() { Usage: reforger-surround create reforger-surround up + reforger-surround launch [command...] reforger-surround expose reforger-surround pin reforger-surround restore @@ -24,6 +27,7 @@ Usage: Commands: create Create the temporary 5.1 sink without changing the default sink. up Create the 5.1 sink, save the current default, and make it default. + launch Run up, launch Reforger, wait for its stream, then restore. expose Create the 5.1 sink and move a running Reforger stream into it. pin Alias for expose. restore Restore the saved previous default sink, then expose Reforger if running. @@ -35,6 +39,8 @@ Environment: REFORGER_SURROUND_SINK_NAME Override sink name. Default: reforger_surround_51 REFORGER_SURROUND_DESCRIPTION Override visible sink name. Default: Reforger Surround 5.1 REFORGER_SURROUND_APP_NAME Override app name. Default: Arma Reforger + REFORGER_SURROUND_STEAM_URI Override Steam URI. Default: steam://rungameid/1874880 + REFORGER_SURROUND_WAIT_SECONDS Override launch wait. Default: 90 EOF } @@ -129,10 +135,14 @@ set_sink_default() { printf 'Set launch default sink: %s\n' "${sink_name}" } -up() { +prepare_launch_default() { create_sink save_previous_default set_sink_default +} + +up() { + prepare_launch_default cat </tmp/reforger-surround-steam.log 2>&1 & + printf 'Requested Steam launch: %s\n' "${steam_uri}" +} + +wait_for_app_stream() { + local input_id elapsed + + for ((elapsed=0; elapsed&2 + printf 'Leaving %s as default so late stream creation can still negotiate 5.1.\n' "${sink_name}" >&2 + printf 'Run `reforger-surround restore` after the game audio stream appears.\n' >&2 + return 1 + fi + + printf 'Detected %s sink-input #%s\n' "${app_name}" "${input_id}" + restore_with_pin + print_check +} + expose_app() { local input_id sample_spec sink_after @@ -374,6 +429,7 @@ main() { usage >&2 exit 1 fi + shift || true case "${command}" in -h|--help|help) @@ -389,6 +445,11 @@ main() { require_pulse_connection up ;; + launch) + ensure_dependencies + require_pulse_connection + launch_game "$@" + ;; expose) ensure_dependencies require_pulse_connection