Alc/backends/jack.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <memory.h>
  26
  27 #include "alMain.h"
  28 #include "alu.h"
  29 #include "threads.h"
  30 #include "compat.h"
  31
  32 #include "backends/base.h"
  33
  34 #include <jack/jack.h>
  35 #include <jack/ringbuffer.h>
  36
  37
  38 static const ALCchar jackDevice[] = "JACK Default";
  39
  40
  41 #ifdef HAVE_DYNLOAD
  42 #define JACK_FUNCS(MAGIC)          \
  43     MAGIC(jack_client_open);       \
  44     MAGIC(jack_client_close);      \
  45     MAGIC(jack_client_name_size);  \
  46     MAGIC(jack_get_client_name);   \
  47     MAGIC(jack_connect);           \
  48     MAGIC(jack_activate);          \
  49     MAGIC(jack_deactivate);        \
  50     MAGIC(jack_port_register);     \
  51     MAGIC(jack_port_unregister);   \
  52     MAGIC(jack_port_get_buffer);   \
  53     MAGIC(jack_port_name);         \
  54     MAGIC(jack_get_ports);         \
  55     MAGIC(jack_free);              \
  56     MAGIC(jack_get_sample_rate);   \
  57     MAGIC(jack_set_error_function); \
  58     MAGIC(jack_set_process_callback); \
  59     MAGIC(jack_set_buffer_size_callback); \
  60     MAGIC(jack_set_buffer_size);   \
  61     MAGIC(jack_get_buffer_size);
  62
  63 static void *jack_handle;
  64 #define MAKE_FUNC(f) static __typeof(f) * p##f
  65 JACK_FUNCS(MAKE_FUNC);
  66 #undef MAKE_FUNC
  67
  68 #define jack_client_open pjack_client_open
  69 #define jack_client_close pjack_client_close
  70 #define jack_client_name_size pjack_client_name_size
  71 #define jack_get_client_name pjack_get_client_name
  72 #define jack_connect pjack_connect
  73 #define jack_activate pjack_activate
  74 #define jack_deactivate pjack_deactivate
  75 #define jack_port_register pjack_port_register
  76 #define jack_port_unregister pjack_port_unregister
  77 #define jack_port_get_buffer pjack_port_get_buffer
  78 #define jack_port_name pjack_port_name
  79 #define jack_get_ports pjack_get_ports
  80 #define jack_free pjack_free
  81 #define jack_get_sample_rate pjack_get_sample_rate
  82 #define jack_set_error_function pjack_set_error_function
  83 #define jack_set_process_callback pjack_set_process_callback
  84 #define jack_set_buffer_size_callback pjack_set_buffer_size_callback
  85 #define jack_set_buffer_size pjack_set_buffer_size
  86 #define jack_get_buffer_size pjack_get_buffer_size
  87 #endif
  88
  89
  90 static jack_options_t ClientOptions = JackNullOption;
  91
  92 static ALCboolean jack_load(void)
  93 {
  94     ALCboolean error = ALC_FALSE;
  95
  96 #ifdef HAVE_DYNLOAD
  97     if(!jack_handle)
  98     {
  99         al_string missing_funcs = AL_STRING_INIT_STATIC();
 100
 101 #ifdef _WIN32
 102 #define JACKLIB "libjack.dll"
 103 #else
 104 #define JACKLIB "libjack.so.0"
 105 #endif
 106         jack_handle = LoadLib(JACKLIB);
 107         if(!jack_handle)
 108         {
 109             WARN("Failed to load %s\n", JACKLIB);
 110             return ALC_FALSE;
 111         }
 112
 113         error = ALC_FALSE;
 114 #define LOAD_FUNC(f) do {                                                     \
 115     p##f = GetSymbol(jack_handle, #f);                                        \
 116     if(p##f == NULL) {                                                        \
 117         error = ALC_TRUE;                                                     \
 118         alstr_append_cstr(&missing_funcs, "\n" #f);                           \
 119     }                                                                         \
 120 } while(0)
 121         JACK_FUNCS(LOAD_FUNC);
 122 #undef LOAD_FUNC
 123
 124         if(error)
 125         {
 126             WARN("Missing expected functions:%s\n", alstr_get_cstr(missing_funcs));
 127             CloseLib(jack_handle);
 128             jack_handle = NULL;
 129         }
 130         alstr_reset(&missing_funcs);
 131     }
 132 #endif
 133
 134     return !error;
 135 }
 136
 137
 138 typedef struct ALCjackPlayback {
 139     DERIVE_FROM_TYPE(ALCbackend);
 140
 141     jack_client_t *Client;
 142     jack_port_t *Port[MAX_OUTPUT_CHANNELS];
 143
 144     ll_ringbuffer_t *Ring;
 145     alcnd_t Cond;
 146
 147     volatile int killNow;
 148     althrd_t thread;
 149 } ALCjackPlayback;
 150
 151 static int ALCjackPlayback_bufferSizeNotify(jack_nframes_t numframes, void *arg);
 152
 153 static int ALCjackPlayback_process(jack_nframes_t numframes, void *arg);
 154 static int ALCjackPlayback_mixerProc(void *arg);
 155
 156 static void ALCjackPlayback_Construct(ALCjackPlayback *self, ALCdevice *device);
 157 static void ALCjackPlayback_Destruct(ALCjackPlayback *self);
 158 static ALCenum ALCjackPlayback_open(ALCjackPlayback *self, const ALCchar *name);
 159 static void ALCjackPlayback_close(ALCjackPlayback *self);
 160 static ALCboolean ALCjackPlayback_reset(ALCjackPlayback *self);
 161 static ALCboolean ALCjackPlayback_start(ALCjackPlayback *self);
 162 static void ALCjackPlayback_stop(ALCjackPlayback *self);
 163 static DECLARE_FORWARD2(ALCjackPlayback, ALCbackend, ALCenum, captureSamples, void*, ALCuint)
 164 static DECLARE_FORWARD(ALCjackPlayback, ALCbackend, ALCuint, availableSamples)
 165 static ClockLatency ALCjackPlayback_getClockLatency(ALCjackPlayback *self);
 166 static DECLARE_FORWARD(ALCjackPlayback, ALCbackend, void, lock)
 167 static DECLARE_FORWARD(ALCjackPlayback, ALCbackend, void, unlock)
 168 DECLARE_DEFAULT_ALLOCATORS(ALCjackPlayback)
 169
 170 DEFINE_ALCBACKEND_VTABLE(ALCjackPlayback);
 171
 172
 173 static void ALCjackPlayback_Construct(ALCjackPlayback *self, ALCdevice *device)
 174 {
 175     ALuint i;
 176
 177     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
 178     SET_VTABLE2(ALCjackPlayback, ALCbackend, self);
 179
 180     alcnd_init(&self->Cond);
 181
 182     self->Client = NULL;
 183     for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
 184         self->Port[i] = NULL;
 185     self->Ring = NULL;
 186
 187     self->killNow = 1;
 188 }
 189
 190 static void ALCjackPlayback_Destruct(ALCjackPlayback *self)
 191 {
 192     ALuint i;
 193
 194     if(self->Client)
 195     {
 196         for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
 197         {
 198             if(self->Port[i])
 199                 jack_port_unregister(self->Client, self->Port[i]);
 200             self->Port[i] = NULL;
 201         }
 202         jack_client_close(self->Client);
 203         self->Client = NULL;
 204     }
 205
 206     alcnd_destroy(&self->Cond);
 207
 208     ALCbackend_Destruct(STATIC_CAST(ALCbackend, self));
 209 }
 210
 211
 212 static int ALCjackPlayback_bufferSizeNotify(jack_nframes_t numframes, void *arg)
 213 {
 214     ALCjackPlayback *self = arg;
 215     ALCdevice *device = STATIC_CAST(ALCbackend,self)->mDevice;
 216     ALuint bufsize;
 217
 218     ALCjackPlayback_lock(self);
 219     device->UpdateSize = numframes;
 220     device->NumUpdates = 2;
 221
 222     bufsize = device->UpdateSize;
 223     if(ConfigValueUInt(alstr_get_cstr(device->DeviceName), "jack", "buffer-size", &bufsize))
 224         bufsize = maxu(NextPowerOf2(bufsize), device->UpdateSize);
 225     bufsize += device->UpdateSize;
 226     device->NumUpdates = bufsize / device->UpdateSize;
 227
 228     TRACE("%u update size x%u\n", device->UpdateSize, device->NumUpdates);
 229
 230     ll_ringbuffer_free(self->Ring);
 231     self->Ring = ll_ringbuffer_create(bufsize,
 232         FrameSizeFromDevFmt(device->FmtChans, device->FmtType, device->AmbiOrder)
 233     );
 234     if(!self->Ring)
 235     {
 236         ERR("Failed to reallocate ringbuffer\n");
 237         aluHandleDisconnect(device);
 238     }
 239     ALCjackPlayback_unlock(self);
 240     return 0;
 241 }
 242
 243
 244 static int ALCjackPlayback_process(jack_nframes_t numframes, void *arg)
 245 {
 246     ALCjackPlayback *self = arg;
 247     jack_default_audio_sample_t *out[MAX_OUTPUT_CHANNELS];
 248     ll_ringbuffer_data_t data[2];
 249     jack_nframes_t total = 0;
 250     jack_nframes_t todo;
 251     ALsizei i, c, numchans;
 252
 253     ll_ringbuffer_get_read_vector(self->Ring, data);
 254
 255     for(c = 0;c < MAX_OUTPUT_CHANNELS && self->Port[c];c++)
 256         out[c] = jack_port_get_buffer(self->Port[c], numframes);
 257     numchans = c;
 258
 259     todo = minu(numframes, data[0].len);
 260     for(c = 0;c < numchans;c++)
 261     {
 262         const ALfloat *restrict in = ((ALfloat*)data[0].buf) + c;
 263         for(i = 0;(jack_nframes_t)i < todo;i++)
 264             out[c][i] = in[i*numchans];
 265         out[c] += todo;
 266     }
 267     total += todo;
 268
 269     todo = minu(numframes-total, data[1].len);
 270     if(todo > 0)
 271     {
 272         for(c = 0;c < numchans;c++)
 273         {
 274             const ALfloat *restrict in = ((ALfloat*)data[1].buf) + c;
 275             for(i = 0;(jack_nframes_t)i < todo;i++)
 276                 out[c][i] = in[i*numchans];
 277             out[c] += todo;
 278         }
 279         total += todo;
 280     }
 281
 282     ll_ringbuffer_read_advance(self->Ring, total);
 283     alcnd_signal(&self->Cond);
 284
 285     if(numframes > total)
 286     {
 287         todo = numframes-total;
 288         for(c = 0;c < numchans;c++)
 289         {
 290             for(i = 0;(jack_nframes_t)i < todo;i++)
 291                 out[c][i] = 0.0f;
 292         }
 293     }
 294
 295     return 0;
 296 }
 297
 298 static int ALCjackPlayback_mixerProc(void *arg)
 299 {
 300     ALCjackPlayback *self = arg;
 301     ALCdevice *device = STATIC_CAST(ALCbackend,self)->mDevice;
 302     ll_ringbuffer_data_t data[2];
 303
 304     SetRTPriority();
 305     althrd_setname(althrd_current(), MIXER_THREAD_NAME);
 306
 307     ALCjackPlayback_lock(self);
 308     while(!self->killNow && device->Connected)
 309     {
 310         ALuint todo, len1, len2;
 311
 312         /* NOTE: Unfortunately, there is an unavoidable race condition here.
 313          * It's possible for the process() method to run, updating the read
 314          * pointer and signaling the condition variable, in between the mixer
 315          * loop checking the write size and waiting for the condition variable.
 316          * This will cause the mixer loop to wait until the *next* process()
 317          * invocation, most likely writing silence for it.
 318          *
 319          * However, this should only happen if the mixer is running behind
 320          * anyway (as ideally we'll be asleep in alcnd_wait by the time the
 321          * process() method is invoked), so this behavior is not unwarranted.
 322          * It's unfortunate since it'll be wasting time sleeping that could be
 323          * used to catch up, but there's no way around it without blocking in
 324          * the process() method.
 325          */
 326         if(ll_ringbuffer_write_space(self->Ring) < device->UpdateSize)
 327         {
 328             alcnd_wait(&self->Cond, &STATIC_CAST(ALCbackend,self)->mMutex);
 329             continue;
 330         }
 331
 332         ll_ringbuffer_get_write_vector(self->Ring, data);
 333         todo  = data[0].len + data[1].len;
 334         todo -= todo%device->UpdateSize;
 335
 336         len1 = minu(data[0].len, todo);
 337         len2 = minu(data[1].len, todo-len1);
 338
 339         aluMixData(device, data[0].buf, len1);
 340         if(len2 > 0)
 341             aluMixData(device, data[1].buf, len2);
 342         ll_ringbuffer_write_advance(self->Ring, todo);
 343     }
 344     ALCjackPlayback_unlock(self);
 345
 346     return 0;
 347 }
 348
 349
 350 static ALCenum ALCjackPlayback_open(ALCjackPlayback *self, const ALCchar *name)
 351 {
 352     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 353     const char *client_name = "alsoft";
 354     jack_status_t status;
 355
 356     if(!name)
 357         name = jackDevice;
 358     else if(strcmp(name, jackDevice) != 0)
 359         return ALC_INVALID_VALUE;
 360
 361     self->Client = jack_client_open(client_name, ClientOptions, &status, NULL);
 362     if(self->Client == NULL)
 363     {
 364         ERR("jack_client_open() failed, status = 0x%02x\n", status);
 365         return ALC_INVALID_VALUE;
 366     }
 367     if((status&JackServerStarted))
 368         TRACE("JACK server started\n");
 369     if((status&JackNameNotUnique))
 370     {
 371         client_name = jack_get_client_name(self->Client);
 372         TRACE("Client name not unique, got `%s' instead\n", client_name);
 373     }
 374
 375     jack_set_process_callback(self->Client, ALCjackPlayback_process, self);
 376     jack_set_buffer_size_callback(self->Client, ALCjackPlayback_bufferSizeNotify, self);
 377
 378     alstr_copy_cstr(&device->DeviceName, name);
 379
 380     return ALC_NO_ERROR;
 381 }
 382
 383 static void ALCjackPlayback_close(ALCjackPlayback *self)
 384 {
 385     ALuint i;
 386
 387     for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
 388     {
 389         if(self->Port[i])
 390             jack_port_unregister(self->Client, self->Port[i]);
 391         self->Port[i] = NULL;
 392     }
 393     jack_client_close(self->Client);
 394     self->Client = NULL;
 395 }
 396
 397 static ALCboolean ALCjackPlayback_reset(ALCjackPlayback *self)
 398 {
 399     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 400     ALsizei numchans, i;
 401     ALuint bufsize;
 402
 403     for(i = 0;i < MAX_OUTPUT_CHANNELS;i++)
 404     {
 405         if(self->Port[i])
 406             jack_port_unregister(self->Client, self->Port[i]);
 407         self->Port[i] = NULL;
 408     }
 409
 410     /* Ignore the requested buffer metrics and just keep one JACK-sized buffer
 411      * ready for when requested. Note that one period's worth of audio in the
 412      * ring buffer will always be left unfilled because one element of the ring
 413      * buffer will not be writeable, and we only write in period-sized chunks.
 414      */
 415     device->Frequency = jack_get_sample_rate(self->Client);
 416     device->UpdateSize = jack_get_buffer_size(self->Client);
 417     device->NumUpdates = 2;
 418
 419     bufsize = device->UpdateSize;
 420     if(ConfigValueUInt(alstr_get_cstr(device->DeviceName), "jack", "buffer-size", &bufsize))
 421         bufsize = maxu(NextPowerOf2(bufsize), device->UpdateSize);
 422     bufsize += device->UpdateSize;
 423     device->NumUpdates = bufsize / device->UpdateSize;
 424
 425     /* Force 32-bit float output. */
 426     device->FmtType = DevFmtFloat;
 427
 428     numchans = ChannelsFromDevFmt(device->FmtChans, device->AmbiOrder);
 429     for(i = 0;i < numchans;i++)
 430     {
 431         char name[64];
 432         snprintf(name, sizeof(name), "channel_%d", i+1);
 433         self->Port[i] = jack_port_register(self->Client, name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
 434         if(self->Port[i] == NULL)
 435         {
 436             ERR("Not enough JACK ports available for %s output\n", DevFmtChannelsString(device->FmtChans));
 437             if(i == 0) return ALC_FALSE;
 438             break;
 439         }
 440     }
 441     if(i < numchans)
 442     {
 443         if(i == 1)
 444             device->FmtChans = DevFmtMono;
 445         else
 446         {
 447             for(--i;i >= 2;i--)
 448             {
 449                 jack_port_unregister(self->Client, self->Port[i]);
 450                 self->Port[i] = NULL;
 451             }
 452             device->FmtChans = DevFmtStereo;
 453         }
 454     }
 455
 456     ll_ringbuffer_free(self->Ring);
 457     self->Ring = ll_ringbuffer_create(bufsize,
 458         FrameSizeFromDevFmt(device->FmtChans, device->FmtType, device->AmbiOrder)
 459     );
 460     if(!self->Ring)
 461     {
 462         ERR("Failed to allocate ringbuffer\n");
 463         return ALC_FALSE;
 464     }
 465
 466     SetDefaultChannelOrder(device);
 467
 468     return ALC_TRUE;
 469 }
 470
 471 static ALCboolean ALCjackPlayback_start(ALCjackPlayback *self)
 472 {
 473     const char **ports;
 474     ALsizei i;
 475
 476     if(jack_activate(self->Client))
 477     {
 478         ERR("Failed to activate client\n");
 479         return ALC_FALSE;
 480     }
 481
 482     ports = jack_get_ports(self->Client, NULL, NULL, JackPortIsPhysical|JackPortIsInput);
 483     if(ports == NULL)
 484     {
 485         ERR("No physical playback ports found\n");
 486         jack_deactivate(self->Client);
 487         return ALC_FALSE;
 488     }
 489     for(i = 0;i < MAX_OUTPUT_CHANNELS && self->Port[i];i++)
 490     {
 491         if(!ports[i])
 492         {
 493             ERR("No physical playback port for \"%s\"\n", jack_port_name(self->Port[i]));
 494             break;
 495         }
 496         if(jack_connect(self->Client, jack_port_name(self->Port[i]), ports[i]))
 497             ERR("Failed to connect output port \"%s\" to \"%s\"\n", jack_port_name(self->Port[i]), ports[i]);
 498     }
 499     jack_free(ports);
 500
 501     self->killNow = 0;
 502     if(althrd_create(&self->thread, ALCjackPlayback_mixerProc, self) != althrd_success)
 503     {
 504         jack_deactivate(self->Client);
 505         return ALC_FALSE;
 506     }
 507
 508     return ALC_TRUE;
 509 }
 510
 511 static void ALCjackPlayback_stop(ALCjackPlayback *self)
 512 {
 513     int res;
 514
 515     if(self->killNow)
 516         return;
 517
 518     self->killNow = 1;
 519     /* Lock the backend to ensure we don't flag the mixer to die and signal the
 520      * mixer to wake up in between it checking the flag and going to sleep and
 521      * wait for a wakeup (potentially leading to it never waking back up to see
 522      * the flag). */
 523     ALCjackPlayback_lock(self);
 524     ALCjackPlayback_unlock(self);
 525     alcnd_signal(&self->Cond);
 526     althrd_join(self->thread, &res);
 527
 528     jack_deactivate(self->Client);
 529 }
 530
 531
 532 static ClockLatency ALCjackPlayback_getClockLatency(ALCjackPlayback *self)
 533 {
 534     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 535     ClockLatency ret;
 536
 537     ALCjackPlayback_lock(self);
 538     ret.ClockTime = GetDeviceClockTime(device);
 539     ret.Latency = ll_ringbuffer_read_space(self->Ring) * DEVICE_CLOCK_RES /
 540                   device->Frequency;
 541     ALCjackPlayback_unlock(self);
 542
 543     return ret;
 544 }
 545
 546
 547 static void jack_msg_handler(const char *message)
 548 {
 549     WARN("%s\n", message);
 550 }
 551
 552 typedef struct ALCjackBackendFactory {
 553     DERIVE_FROM_TYPE(ALCbackendFactory);
 554 } ALCjackBackendFactory;
 555 #define ALCJACKBACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCjackBackendFactory, ALCbackendFactory) } }
 556
 557 static ALCboolean ALCjackBackendFactory_init(ALCjackBackendFactory* UNUSED(self))
 558 {
 559     jack_client_t *client;
 560     jack_status_t status;
 561
 562     if(!jack_load())
 563         return ALC_FALSE;
 564
 565     if(!GetConfigValueBool(NULL, "jack", "spawn-server", 0))
 566         ClientOptions |= JackNoStartServer;
 567
 568     jack_set_error_function(jack_msg_handler);
 569     client = jack_client_open("alsoft", ClientOptions, &status, NULL);
 570     jack_set_error_function(NULL);
 571     if(client == NULL)
 572     {
 573         WARN("jack_client_open() failed, 0x%02x\n", status);
 574         if((status&JackServerFailed) && !(ClientOptions&JackNoStartServer))
 575             ERR("Unable to connect to JACK server\n");
 576         return ALC_FALSE;
 577     }
 578
 579     jack_client_close(client);
 580     return ALC_TRUE;
 581 }
 582
 583 static void ALCjackBackendFactory_deinit(ALCjackBackendFactory* UNUSED(self))
 584 {
 585 #ifdef HAVE_DYNLOAD
 586     if(jack_handle)
 587         CloseLib(jack_handle);
 588     jack_handle = NULL;
 589 #endif
 590 }
 591
 592 static ALCboolean ALCjackBackendFactory_querySupport(ALCjackBackendFactory* UNUSED(self), ALCbackend_Type type)
 593 {
 594     if(type == ALCbackend_Playback)
 595         return ALC_TRUE;
 596     return ALC_FALSE;
 597 }
 598
 599 static void ALCjackBackendFactory_probe(ALCjackBackendFactory* UNUSED(self), enum DevProbe type)
 600 {
 601     switch(type)
 602     {
 603         case ALL_DEVICE_PROBE:
 604             AppendAllDevicesList(jackDevice);
 605             break;
 606
 607         case CAPTURE_DEVICE_PROBE:
 608             break;
 609     }
 610 }
 611
 612 static ALCbackend* ALCjackBackendFactory_createBackend(ALCjackBackendFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type)
 613 {
 614     if(type == ALCbackend_Playback)
 615     {
 616         ALCjackPlayback *backend;
 617         NEW_OBJ(backend, ALCjackPlayback)(device);
 618         if(!backend) return NULL;
 619         return STATIC_CAST(ALCbackend, backend);
 620     }
 621
 622     return NULL;
 623 }
 624
 625 DEFINE_ALCBACKENDFACTORY_VTABLE(ALCjackBackendFactory);
 626
 627
 628 ALCbackendFactory *ALCjackBackendFactory_getFactory(void)
 629 {
 630     static ALCjackBackendFactory factory = ALCJACKBACKENDFACTORY_INITIALIZER;
 631     return STATIC_CAST(ALCbackendFactory, &factory);
 632 }