server/scsynth/SC_SequencedCommand.cpp

   1 /*
   2         SuperCollider real time audio synthesis system
   3     Copyright (c) 2002 James McCartney. All rights reserved.
   4         http://www.audiosynth.com
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  19 */
  20
  21
  22 #include "SC_SequencedCommand.h"
  23 #include "SC_CoreAudio.h"
  24 #include "SC_Errors.h"
  25 #include "scsynthsend.h"
  26 #include "SC_Prototypes.h"
  27 #include "SC_HiddenWorld.h"
  28 #include "SC_Sem.h"
  29 #include "SC_DirUtils.h"
  30 #include "SC_StringParser.h"
  31 #include "../../common/SC_SndFileHelpers.hpp"
  32
  33 #define GET_COMPLETION_MSG(msg) \
  34         mMsgSize = msg.getbsize(); \
  35         if (mMsgSize) { \
  36                 mMsgData = (char*)World_Alloc(mWorld, mMsgSize); \
  37                 msg.getb(mMsgData, mMsgSize); \
  38         }
  39
  40 void PerformCompletionMsg(World *inWorld, OSC_Packet *inPacket);
  41
  42 #define SEND_COMPLETION_MSG \
  43         if (mMsgSize) { \
  44                 OSC_Packet packet; \
  45                 packet.mData = mMsgData; \
  46                 packet.mSize = mMsgSize; \
  47                 packet.mReplyAddr = mReplyAddress; \
  48                 PacketStatus status = PerformCompletionMsg(mWorld, packet); \
  49                 if (status == PacketScheduled) { \
  50                         mMsgSize = 0; \
  51                         mMsgData = 0; \
  52                 } \
  53         }
  54
  55 void SndBuf_Init(SndBuf *buf);
  56 void SndBuf_Init(SndBuf *buf)
  57 {
  58         buf->data = 0;
  59         buf->channels = 0;
  60         buf->samples = 0;
  61         buf->frames = 0;
  62         buf->mask = 0;
  63         buf->mask1 = 0;
  64         buf->coord = 0;
  65         buf->sndfile = 0;
  66 }
  67
  68 char* allocAndRestrictPath(World *mWorld, const char* inPath, const char* restrictBase);
  69 char* allocAndRestrictPath(World *mWorld, const char* inPath, const char* restrictBase){
  70         char strbuf[PATH_MAX];
  71         int offset = 0;
  72         int remain = PATH_MAX;
  73
  74         // Ensure begins with the base
  75         if(strncmp(inPath, restrictBase, strlen(restrictBase)) != 0){
  76                 strcpy(strbuf, restrictBase);
  77                 offset = strlen(restrictBase);
  78                 remain -= offset;
  79                 if(inPath[0]!='/' && strbuf[strlen(strbuf)-1]!='/'){
  80                         strbuf[offset] = '/';
  81                         ++offset;
  82                         --remain;
  83                 }
  84         }
  85
  86         // Now copy string, but discard any ".." (which could be benign, but easy to abuse)
  87         SC_StringParser sp(inPath, '/');
  88         size_t tokenlen;
  89         while (!sp.AtEnd()) {
  90                 const char *token = const_cast<char *>(sp.NextToken());
  91                 tokenlen = strlen(token);
  92                 // now add the new token, then a slash, as long as token is neither dodgy nor overflows
  93                 if(strcmp(token, "..")!=0 && remain > tokenlen){
  94                         strcpy(strbuf+offset, token);
  95                         offset += tokenlen;
  96                         remain -= tokenlen;
  97                         if(!sp.AtEnd()) {
  98                                 strbuf[offset] = '/';
  99                                 ++offset;
 100                                 --remain;
 101                         }
 102                 }
 103         }
 104
 105         // Now we can make a long-term home for the string and return it
 106         char* saferPath = (char*)World_Alloc(mWorld, strlen(strbuf)+1);
 107         strcpy(saferPath, strbuf);
 108         return saferPath;
 109 }
 110
 111 SC_SequencedCommand::SC_SequencedCommand(World *inWorld, ReplyAddress *inReplyAddress)
 112         : mNextStage(1), mWorld(inWorld),
 113         mMsgSize(0), mMsgData(0)
 114 {
 115         if (inReplyAddress) mReplyAddress = *inReplyAddress;
 116         else mReplyAddress.mReplyFunc = null_reply_func;
 117 }
 118
 119 SC_SequencedCommand::~SC_SequencedCommand()
 120 {
 121         if (mMsgData) World_Free(mWorld, mMsgData);
 122 }
 123
 124 int SC_SequencedCommand::Init(char* /*inData*/, int /*inSize*/)
 125 {
 126         return kSCErr_None;
 127 }
 128
 129 void SC_SequencedCommand::SendDone(const char *inCommandName)
 130 {
 131         ::SendDone(&mReplyAddress, inCommandName);
 132 };
 133
 134 void SC_SequencedCommand::SendDoneWithIntValue(const char *inCommandName, int value)
 135 {
 136         ::SendDoneWithIntValue(&mReplyAddress, inCommandName, value);
 137 };
 138
 139 void SC_SequencedCommand::CallEveryStage()
 140 {
 141         switch (mNextStage) {
 142                 case 1 : if (!Stage1()) break; mNextStage++;
 143                 case 2 : if (!Stage2()) break; mNextStage++;
 144                 case 3 : if (!Stage3()) break; mNextStage++;
 145                 case 4 : Stage4(); break;
 146         }
 147         Delete();
 148 }
 149
 150 void DoSequencedCommand(FifoMsg *inMsg);
 151 void DoSequencedCommand(FifoMsg *inMsg)
 152 {
 153         SC_SequencedCommand *cmd = (SC_SequencedCommand*)inMsg->mData;
 154         cmd->CallNextStage();
 155 }
 156
 157 void FreeSequencedCommand(FifoMsg *inMsg);
 158 void FreeSequencedCommand(FifoMsg *inMsg)
 159 {
 160         SC_SequencedCommand *cmd = (SC_SequencedCommand*)inMsg->mData;
 161         cmd->Delete();
 162 }
 163
 164
 165 void SC_SequencedCommand::CallNextStage()
 166 {
 167         bool sendAgain = false;
 168         FifoMsg msg;
 169
 170         int isRealTime = mNextStage & 1;
 171         switch (mNextStage) {
 172                 case 1 :
 173                         sendAgain = Stage1(); // RT
 174                         break;
 175                 case 2 :
 176                         sendAgain = Stage2(); // NRT
 177                         break;
 178                 case 3 :
 179                         sendAgain = Stage3(); // RT
 180                         break;
 181                 case 4 :
 182                         Stage4();                       // NRT
 183                         break;
 184         }
 185         mNextStage++;
 186         SC_AudioDriver *driver = AudioDriver(mWorld);
 187         if (sendAgain) {
 188                 msg.Set(mWorld, DoSequencedCommand, 0, (void*)this);
 189                 // send this to next time.
 190                 if (isRealTime) {
 191                         // send to NRT
 192                         driver->SendMsgFromEngine(msg);
 193                 } else {
 194                         // send to RT
 195                         driver->SendMsgToEngine(msg);
 196                 }
 197         } else {
 198                 if (isRealTime) {
 199                         Delete();
 200                 } else {
 201                         // can only be freed from RT.
 202                         msg.Set(mWorld, FreeSequencedCommand, 0, (void*)this);
 203                         driver->SendMsgToEngine(msg);
 204                 }
 205         }
 206 }
 207
 208 void SC_SequencedCommand::Delete()
 209 {
 210         CallDestructor();
 211         World_Free(mWorld, this);
 212 }
 213
 214 bool SC_SequencedCommand::Stage1()
 215 {
 216         return true;
 217 }
 218
 219 bool SC_SequencedCommand::Stage2()
 220 {
 221         return false;
 222 }
 223
 224 bool SC_SequencedCommand::Stage3()
 225 {
 226         return false;
 227 }
 228
 229 void SC_SequencedCommand::Stage4()
 230 {
 231 }
 232
 233
 234 ///////////////////////////////////////////////////////////////////////////
 235
 236 #include "sc_msg_iter.h"
 237 #include <string.h>
 238
 239 SyncCmd::SyncCmd(World *inWorld, ReplyAddress *inReplyAddress)
 240         : SC_SequencedCommand(inWorld, inReplyAddress)
 241 {
 242 }
 243
 244 int SyncCmd::Init(char *inData, int inSize)
 245 {
 246         sc_msg_iter msg(inSize, inData);
 247         mID = msg.geti();
 248         return kSCErr_None;
 249 }
 250
 251 void SyncCmd::CallDestructor()
 252 {
 253         this->~SyncCmd();
 254 }
 255
 256 bool SyncCmd::Stage2()
 257 {
 258         return true;
 259 }
 260
 261 bool SyncCmd::Stage3()
 262 {
 263         return true;
 264 }
 265
 266 void SyncCmd::Stage4()
 267 {
 268         small_scpacket packet;
 269         packet.adds("/synced");
 270         packet.maketags(2);
 271         packet.addtag(',');
 272         packet.addtag('i');
 273
 274         packet.addi(mID);
 275
 276         SendReply(&mReplyAddress, packet.data(), packet.size());
 277 }
 278
 279 ///////////////////////////////////////////////////////////////////////////
 280
 281 BufAllocCmd::BufAllocCmd(World *inWorld, ReplyAddress *inReplyAddress)
 282         : SC_SequencedCommand(inWorld, inReplyAddress)
 283 {
 284 }
 285
 286 int BufAllocCmd::Init(char *inData, int inSize)
 287 {
 288         sc_msg_iter msg(inSize, inData);
 289         mBufIndex = msg.geti();
 290         mNumFrames = msg.geti();
 291         mNumChannels = msg.geti(1);
 292
 293         GET_COMPLETION_MSG(msg);
 294
 295         return kSCErr_None;
 296 }
 297
 298 void BufAllocCmd::CallDestructor()
 299 {
 300         this->~BufAllocCmd();
 301 }
 302
 303 bool BufAllocCmd::Stage2()
 304 {
 305         SndBuf *buf = World_GetNRTBuf(mWorld, mBufIndex);
 306         mFreeData = buf->data;
 307         bufAlloc(buf, mNumChannels, mNumFrames, mWorld->mFullRate.mSampleRate);
 308         mSndBuf = *buf;
 309         return true;
 310 }
 311
 312 bool BufAllocCmd::Stage3()
 313 {
 314         SndBuf* buf = World_GetBuf(mWorld, mBufIndex);
 315         *buf = mSndBuf;
 316         mWorld->mSndBufUpdates[mBufIndex].writes ++ ;
 317         SEND_COMPLETION_MSG;
 318         return true;
 319 }
 320
 321 void BufAllocCmd::Stage4()
 322 {
 323         free(mFreeData);
 324         SendDoneWithIntValue("/b_alloc", mBufIndex);
 325 }
 326
 327 ///////////////////////////////////////////////////////////////////////////
 328
 329 #include "sc_msg_iter.h"
 330 #include <string.h>
 331
 332 BufGenCmd::BufGenCmd(World *inWorld, ReplyAddress *inReplyAddress)
 333         : SC_SequencedCommand(inWorld, inReplyAddress),
 334         mData(0)
 335 {
 336 }
 337
 338 BufGenCmd::~BufGenCmd()
 339 {
 340         World_Free(mWorld, mData);
 341 }
 342
 343 int BufGenCmd::Init(char *inData, int inSize)
 344 {
 345         mSize = inSize;
 346         mData = (char*)World_Alloc(mWorld, mSize);
 347         memcpy(mData, inData, mSize);
 348
 349         sc_msg_iter msg(mSize, mData);
 350         mBufIndex = msg.geti();
 351
 352         int32 *genName = msg.gets4();
 353         if (!genName) return kSCErr_WrongArgType;
 354
 355         mBufGen = GetBufGen(genName);
 356         if (!mBufGen) return kSCErr_BufGenNotFound;
 357
 358         mMsg = msg;
 359
 360         return kSCErr_None;
 361 }
 362
 363 void BufGenCmd::CallDestructor()
 364 {
 365         this->~BufGenCmd();
 366 }
 367
 368 bool BufGenCmd::Stage2()
 369 {
 370         SndBuf *buf = World_GetNRTBuf(mWorld, mBufIndex);
 371
 372         mFreeData = buf->data;
 373         (*mBufGen->mBufGenFunc)(mWorld, buf, &mMsg);
 374         if (buf->data == mFreeData) mFreeData = NULL;
 375         mSndBuf = *buf;
 376         return true;
 377 }
 378
 379 bool BufGenCmd::Stage3()
 380 {
 381         SndBuf* buf = World_GetBuf(mWorld, mBufIndex);
 382         *buf = mSndBuf;
 383         mWorld->mSndBufUpdates[mBufIndex].writes ++ ;
 384         return true;
 385 }
 386
 387 void BufGenCmd::Stage4()
 388 {
 389         free(mFreeData);
 390         SendDoneWithIntValue("/b_gen", mBufIndex);
 391 }
 392
 393
 394 ///////////////////////////////////////////////////////////////////////////
 395
 396
 397 ///////////////////////////////////////////////////////////////////////////
 398
 399
 400 BufFreeCmd::BufFreeCmd(World *inWorld, ReplyAddress *inReplyAddress)
 401         : SC_SequencedCommand(inWorld, inReplyAddress)
 402 {
 403 }
 404
 405 int BufFreeCmd::Init(char *inData, int inSize)
 406 {
 407         sc_msg_iter msg(inSize, inData);
 408         mBufIndex = msg.geti();
 409
 410         GET_COMPLETION_MSG(msg);
 411
 412         return kSCErr_None;
 413 }
 414
 415 void BufFreeCmd::CallDestructor()
 416 {
 417         this->~BufFreeCmd();
 418 }
 419
 420 bool BufFreeCmd::Stage2()
 421 {
 422         SndBuf *buf = World_GetNRTBuf(mWorld, mBufIndex);
 423         mFreeData = buf->data;
 424 #ifndef NO_LIBSNDFILE
 425         if (buf->sndfile) sf_close(buf->sndfile);
 426 #endif
 427         SndBuf_Init(buf);
 428         return true;
 429 }
 430
 431 bool BufFreeCmd::Stage3()
 432 {
 433         SndBuf *buf = World_GetBuf(mWorld, mBufIndex);
 434
 435         SndBuf_Init(buf);
 436         mWorld->mSndBufUpdates[mBufIndex].writes ++ ;
 437         SEND_COMPLETION_MSG;
 438
 439         return true;
 440 }
 441
 442 void BufFreeCmd::Stage4()
 443 {
 444         free(mFreeData);
 445         SendDoneWithIntValue("/b_free", mBufIndex);
 446 }
 447
 448 ///////////////////////////////////////////////////////////////////////////
 449
 450 BufZeroCmd::BufZeroCmd(World *inWorld, ReplyAddress *inReplyAddress)
 451         : SC_SequencedCommand(inWorld, inReplyAddress)
 452 {
 453 }
 454
 455 int BufZeroCmd::Init(char *inData, int inSize)
 456 {
 457         sc_msg_iter msg(inSize, inData);
 458         mBufIndex = msg.geti();
 459
 460         GET_COMPLETION_MSG(msg);
 461
 462         return kSCErr_None;
 463 }
 464
 465 void BufZeroCmd::CallDestructor()
 466 {
 467         this->~BufZeroCmd();
 468 }
 469
 470 bool BufZeroCmd::Stage2()
 471 {
 472         SndBuf *buf = World_GetNRTBuf(mWorld, mBufIndex);
 473         memset(buf->data, 0, buf->samples * sizeof(float));
 474         return true;
 475 }
 476
 477 bool BufZeroCmd::Stage3()
 478 {
 479         mWorld->mSndBufUpdates[mBufIndex].writes ++ ;
 480         SEND_COMPLETION_MSG;
 481         return true;
 482 }
 483
 484 void BufZeroCmd::Stage4()
 485 {
 486         SendDoneWithIntValue("/b_zero", mBufIndex);
 487 }
 488
 489 ///////////////////////////////////////////////////////////////////////////
 490
 491 BufAllocReadCmd::BufAllocReadCmd(World *inWorld, ReplyAddress *inReplyAddress)
 492         : SC_SequencedCommand(inWorld, inReplyAddress), mFreeData(0), mFilename(0)
 493 {
 494 }
 495
 496 int BufAllocReadCmd::Init(char *inData, int inSize)
 497 {
 498         sc_msg_iter msg(inSize, inData);
 499         mBufIndex = msg.geti();
 500
 501         const char *filename = msg.gets();
 502         if (!filename) return kSCErr_WrongArgType;
 503
 504         if(mWorld->mRestrictedPath){
 505                 mFilename = allocAndRestrictPath(mWorld, filename, mWorld->mRestrictedPath);
 506         }else{
 507                 mFilename = (char*)World_Alloc(mWorld, strlen(filename)+1);
 508                 strcpy(mFilename, filename);
 509         }
 510
 511         mFileOffset = msg.geti();
 512         mNumFrames = msg.geti();
 513
 514         GET_COMPLETION_MSG(msg);
 515
 516         return kSCErr_None;
 517 }
 518
 519 BufAllocReadCmd::~BufAllocReadCmd()
 520 {
 521         World_Free(mWorld, mFilename);
 522 }
 523
 524 void BufAllocReadCmd::CallDestructor()
 525 {
 526         this->~BufAllocReadCmd();
 527 }
 528
 529 bool BufAllocReadCmd::Stage2()
 530 {
 531 #ifdef NO_LIBSNDFILE
 532         SendFailure(&mReplyAddress, "/b_allocRead", "scsynth compiled without libsndfile\n");
 533         scprintf("scsynth compiled without libsndfile\n");
 534         return false;
 535 #else
 536         SndBuf *buf = World_GetNRTBuf(mWorld, mBufIndex);
 537         SF_INFO fileinfo;
 538         memset(&fileinfo, 0, sizeof(fileinfo));
 539         SNDFILE* sf = sf_open(mFilename, SFM_READ, &fileinfo);
 540         if (!sf) {
 541                 char str[512];
 542                 sprintf(str, "File '%s' could not be opened: %s\n", mFilename, sf_strerror(NULL));
 543                 SendFailureWithBufnum(&mReplyAddress, "/b_allocRead", str, mBufIndex);  //SendFailure(&mReplyAddress, "/b_allocRead", str);
 544                 scprintf(str);
 545                 return false;
 546         }
 547         if (mFileOffset < 0) mFileOffset = 0;
 548         else if (mFileOffset > fileinfo.frames) mFileOffset = fileinfo.frames;
 549         if (mNumFrames <= 0 || mNumFrames + mFileOffset > fileinfo.frames) mNumFrames = fileinfo.frames - mFileOffset;
 550
 551         // alloc data size
 552         mFreeData = buf->data;
 553         SCErr err = bufAlloc(buf, fileinfo.channels, mNumFrames, fileinfo.samplerate);
 554         if (err) goto leave;
 555
 556         sf_seek(sf, mFileOffset, SEEK_SET);
 557         sf_readf_float(sf, buf->data, mNumFrames);
 558
 559 leave:
 560         mSndBuf = *buf;
 561         sf_close(sf);
 562
 563         return true;
 564 #endif
 565 }
 566
 567 bool BufAllocReadCmd::Stage3()
 568 {
 569         SndBuf* buf = World_GetBuf(mWorld, mBufIndex);
 570         *buf = mSndBuf;
 571         mWorld->mSndBufUpdates[mBufIndex].writes ++ ;
 572         SEND_COMPLETION_MSG;
 573
 574         return true;
 575 }
 576
 577 void BufAllocReadCmd::Stage4()
 578 {
 579         free(mFreeData);
 580         SendDoneWithIntValue("/b_allocRead", mBufIndex);
 581 }
 582
 583 ///////////////////////////////////////////////////////////////////////////
 584
 585 BufReadCmd::BufReadCmd(World *inWorld, ReplyAddress *inReplyAddress)
 586         : SC_SequencedCommand(inWorld, inReplyAddress),
 587         mFilename(0)
 588 {
 589 }
 590
 591 int BufReadCmd::Init(char *inData, int inSize)
 592 {
 593         sc_msg_iter msg(inSize, inData);
 594         mBufIndex = msg.geti();
 595
 596         const char *filename = msg.gets();
 597         if (!filename) return kSCErr_WrongArgType;
 598
 599         if(mWorld->mRestrictedPath){
 600                 mFilename = allocAndRestrictPath(mWorld, filename, mWorld->mRestrictedPath);
 601         }else{
 602                 mFilename = (char*)World_Alloc(mWorld, strlen(filename)+1);
 603                 strcpy(mFilename, filename);
 604         }
 605
 606         mFileOffset = msg.geti();
 607         mNumFrames = msg.geti(-1);
 608         mBufOffset = msg.geti();
 609         mLeaveFileOpen = msg.geti();
 610
 611         GET_COMPLETION_MSG(msg);
 612
 613         return kSCErr_None;
 614 }
 615
 616 BufReadCmd::~BufReadCmd()
 617 {
 618         World_Free(mWorld, mFilename);
 619 }
 620
 621 void BufReadCmd::CallDestructor()
 622 {
 623         this->~BufReadCmd();
 624 }
 625
 626 bool BufReadCmd::Stage2()
 627 {
 628 #ifdef NO_LIBSNDFILE
 629         SendFailure(&mReplyAddress, "/b_read", "scsynth compiled without libsndfile\n");
 630         scprintf("scsynth compiled without libsndfile\n");
 631         return false;
 632 #else
 633         SF_INFO fileinfo;
 634
 635         SndBuf *buf = World_GetNRTBuf(mWorld, mBufIndex);
 636         int framesToEnd = buf->frames - mBufOffset;
 637         if (framesToEnd <= 0) return true;
 638
 639         SNDFILE* sf = sf_open(mFilename, SFM_READ, &fileinfo);
 640         if (!sf) {
 641                 char str[512];
 642                 sprintf(str, "File '%s' could not be opened: %s\n", mFilename, sf_strerror(NULL));
 643                 SendFailureWithBufnum(&mReplyAddress, "/b_read", str, mBufIndex); //SendFailure(&mReplyAddress, "/b_read", str);
 644                 scprintf(str);
 645                 return false;
 646         }
 647         if (fileinfo.channels != buf->channels) {
 648                 char str[512];
 649                 sf_close(sf);
 650                 sprintf(str, "Channel mismatch. File '%s' has %d channels. Buffer has %d channels.\n", mFilename, fileinfo.channels, buf->channels);
 651                 SendFailureWithBufnum(&mReplyAddress, "/b_read", str, mBufIndex); //SendFailure(&mReplyAddress, "/b_read", str);
 652                 scprintf(str);
 653                 return false;
 654         }
 655
 656         if (mFileOffset < 0) mFileOffset = 0;
 657         else if (mFileOffset > fileinfo.frames) mFileOffset = fileinfo.frames;
 658         if (mNumFrames < 0 || mNumFrames + mFileOffset > fileinfo.frames) mNumFrames = fileinfo.frames - mFileOffset;
 659
 660         if (mNumFrames > framesToEnd) mNumFrames = framesToEnd;
 661
 662         sf_seek(sf, mFileOffset, SEEK_SET);
 663         if (mNumFrames > 0) {
 664                 sf_readf_float(sf, buf->data + (mBufOffset * buf->channels), mNumFrames);
 665         }
 666
 667         if(buf->sndfile)
 668                 sf_close(buf->sndfile);
 669
 670         if (mLeaveFileOpen) {
 671                 buf->sndfile = sf;
 672         } else {
 673                 sf_close(sf);
 674                 buf->sndfile = 0;
 675         }
 676
 677         mSampleRate = (double)fileinfo.samplerate;
 678
 679         return true;
 680 #endif
 681 }
 682
 683 bool BufReadCmd::Stage3()
 684 {
 685         SndBuf* buf = World_GetBuf(mWorld, mBufIndex);
 686         buf->samplerate = mSampleRate;
 687         if (mLeaveFileOpen) buf->mask = buf->mask1 = -1;
 688
 689         mWorld->mSndBufUpdates[mBufIndex].writes ++ ;
 690         SEND_COMPLETION_MSG;
 691         return true;
 692 }
 693
 694 void BufReadCmd::Stage4()
 695 {
 696         SendDoneWithIntValue("/b_read", mBufIndex);
 697 }
 698
 699 ///////////////////////////////////////////////////////////////////////////
 700
 701 SC_BufReadCommand::SC_BufReadCommand(World* inWorld, ReplyAddress* inReplyAddress)
 702         : SC_SequencedCommand(inWorld, inReplyAddress),
 703           mNumChannels(0)
 704 {
 705 }
 706
 707 SC_BufReadCommand::~SC_BufReadCommand()
 708 {
 709 }
 710
 711 void SC_BufReadCommand::InitChannels(sc_msg_iter& msg)
 712 {
 713         mNumChannels = 0;
 714         while (msg.nextTag(0) == 'i') {
 715                 int c = msg.geti();
 716                 if (mNumChannels <= kMaxNumChannels) {
 717                         mChannels[mNumChannels++] = c;
 718                 }
 719         }
 720 }
 721
 722 bool SC_BufReadCommand::CheckChannels(int inNumChannels)
 723 {
 724         for (int i=0; i < mNumChannels; ++i) {
 725                 if (mChannels[i] >= inNumChannels) {
 726                         return false;
 727                 }
 728         }
 729         return true;
 730 }
 731
 732 void SC_BufReadCommand::CopyChannels(float* dst, float* src, size_t srcChannels, size_t numFrames)
 733 {
 734         for (int ci=0; ci < mNumChannels; ++ci) {
 735                 int c = mChannels[ci];
 736                 if (c >= 0 && c < srcChannels) {
 737                         for (size_t fi=0; fi < numFrames; ++fi) {
 738                                 dst[fi*mNumChannels+ci] = src[fi*srcChannels+c];
 739                         }
 740                 } else {
 741                         for (size_t fi=0; fi < numFrames; ++fi) {
 742                                 dst[fi*mNumChannels+ci] = 0.f;
 743                         }
 744                 }
 745         }
 746 }
 747
 748 ///////////////////////////////////////////////////////////////////////////
 749
 750 BufAllocReadChannelCmd::BufAllocReadChannelCmd(World *inWorld, ReplyAddress *inReplyAddress)
 751         : SC_BufReadCommand(inWorld, inReplyAddress),
 752           mFreeData(0), mFilename(0)
 753 {
 754 }
 755
 756 int BufAllocReadChannelCmd::Init(char *inData, int inSize)
 757 {
 758         sc_msg_iter msg(inSize, inData);
 759         mBufIndex = msg.geti();
 760
 761         const char *filename = msg.gets();
 762         if (!filename) return kSCErr_WrongArgType;
 763
 764         if(mWorld->mRestrictedPath){
 765                 mFilename = allocAndRestrictPath(mWorld, filename, mWorld->mRestrictedPath);
 766         }else{
 767                 mFilename = (char*)World_Alloc(mWorld, strlen(filename)+1);
 768                 strcpy(mFilename, filename);
 769         }
 770
 771         mFileOffset = msg.geti();
 772         mNumFrames = msg.geti();
 773
 774         InitChannels(msg);
 775
 776         GET_COMPLETION_MSG(msg);
 777
 778         return kSCErr_None;
 779 }
 780
 781 BufAllocReadChannelCmd::~BufAllocReadChannelCmd()
 782 {
 783         World_Free(mWorld, mFilename);
 784 }
 785
 786 void BufAllocReadChannelCmd::CallDestructor()
 787 {
 788         this->~BufAllocReadChannelCmd();
 789 }
 790
 791 bool BufAllocReadChannelCmd::Stage2()
 792 {
 793 #ifdef NO_LIBSNDFILE
 794         SendFailure(&mReplyAddress, "/b_allocReadChannel", "scsynth compiled without libsndfile\n");
 795         scprintf("scsynth compiled without libsndfile\n");
 796         return false;
 797 #else
 798         SndBuf *buf = World_GetNRTBuf(mWorld, mBufIndex);
 799
 800         SF_INFO fileinfo;
 801         memset(&fileinfo, 0, sizeof(fileinfo));
 802         SNDFILE* sf = sf_open(mFilename, SFM_READ, &fileinfo);
 803         if (!sf) {
 804                 char str[512];
 805                 sprintf(str, "File '%s' could not be opened: %s\n", mFilename, sf_strerror(NULL));
 806                 SendFailureWithBufnum(&mReplyAddress, "/b_allocReadChannel", str, mBufIndex); //SendFailure(&mReplyAddress, "/b_allocRead", str);
 807                 scprintf(str);
 808                 return false;
 809         }
 810         if (mFileOffset < 0) mFileOffset = 0;
 811         else if (mFileOffset > fileinfo.frames) mFileOffset = fileinfo.frames;
 812         if (mNumFrames <= 0 || mNumFrames + mFileOffset > fileinfo.frames) mNumFrames = fileinfo.frames - mFileOffset;
 813
 814         if (mNumChannels == 0) {
 815                 // alloc data size
 816                 mFreeData = buf->data;
 817                 SCErr err = bufAlloc(buf, fileinfo.channels, mNumFrames, fileinfo.samplerate);
 818                 if (err) goto leave;
 819                 // read all channels
 820                 sf_seek(sf, mFileOffset, SEEK_SET);
 821                 sf_readf_float(sf, buf->data, mNumFrames);
 822         } else {
 823                 // verify channel indexes
 824                 if (!CheckChannels(fileinfo.channels)) {
 825             const char* str = "Channel index out of range.\n";
 826                         SendFailureWithBufnum(&mReplyAddress, "/b_allocReadChannel", str, mBufIndex); //SendFailure(&mReplyAddress, "/b_allocRead", str);
 827                         scprintf(str);
 828                         sf_close(sf);
 829                         return false;
 830                 }
 831                 // alloc data size
 832                 mFreeData = buf->data;
 833                 SCErr err = bufAlloc(buf, mNumChannels, mNumFrames, fileinfo.samplerate);
 834                 if (err) goto leave;
 835                 // alloc temp buffer
 836                 float* data = (float*)malloc(mNumFrames*fileinfo.channels*sizeof(float));
 837                 if (data == 0) goto leave;
 838                 // read some channels
 839                 sf_seek(sf, mFileOffset, SEEK_SET);
 840                 sf_readf_float(sf, data, mNumFrames);
 841                 CopyChannels(buf->data, data, fileinfo.channels, mNumFrames);
 842                 // free temp buffer
 843                 free(data);
 844         }
 845
 846 leave:
 847         mSndBuf = *buf;
 848         sf_close(sf);
 849
 850         return true;
 851 #endif
 852 }
 853
 854 bool BufAllocReadChannelCmd::Stage3()
 855 {
 856         SndBuf* buf = World_GetBuf(mWorld, mBufIndex);
 857         *buf = mSndBuf;
 858         mWorld->mSndBufUpdates[mBufIndex].writes ++ ;
 859         SEND_COMPLETION_MSG;
 860
 861         return true;
 862 }
 863
 864 void BufAllocReadChannelCmd::Stage4()
 865 {
 866         free(mFreeData);
 867         SendDoneWithIntValue("/b_allocReadChannel", mBufIndex);
 868 }
 869
 870 ///////////////////////////////////////////////////////////////////////////
 871
 872 BufReadChannelCmd::BufReadChannelCmd(World *inWorld, ReplyAddress *inReplyAddress)
 873         : SC_BufReadCommand(inWorld, inReplyAddress),
 874           mFilename(0)
 875 {
 876 }
 877
 878 int BufReadChannelCmd::Init(char *inData, int inSize)
 879 {
 880         sc_msg_iter msg(inSize, inData);
 881         mBufIndex = msg.geti();
 882
 883         const char *filename = msg.gets();
 884         if (!filename) return kSCErr_WrongArgType;
 885
 886         if(mWorld->mRestrictedPath){
 887                 mFilename = allocAndRestrictPath(mWorld, filename, mWorld->mRestrictedPath);
 888         }else{
 889                 mFilename = (char*)World_Alloc(mWorld, strlen(filename)+1);
 890                 strcpy(mFilename, filename);
 891         }
 892
 893         mFileOffset = msg.geti();
 894         mNumFrames = msg.geti(-1);
 895         mBufOffset = msg.geti();
 896         mLeaveFileOpen = msg.geti();
 897
 898         InitChannels(msg);
 899
 900         GET_COMPLETION_MSG(msg);
 901
 902         return kSCErr_None;
 903 }
 904
 905 BufReadChannelCmd::~BufReadChannelCmd()
 906 {
 907         World_Free(mWorld, mFilename);
 908 }
 909
 910 void BufReadChannelCmd::CallDestructor()
 911 {
 912         this->~BufReadChannelCmd();
 913 }
 914
 915 bool BufReadChannelCmd::Stage2()
 916 {
 917 #ifdef NO_LIBSNDFILE
 918         SendFailure(&mReplyAddress, "/b_readChannel", "scsynth compiled without libsndfile\n");
 919         scprintf("scsynth compiled without libsndfile\n");
 920         return false;
 921 #else
 922         SF_INFO fileinfo;
 923
 924         SndBuf *buf = World_GetNRTBuf(mWorld, mBufIndex);
 925         int framesToEnd = buf->frames - mBufOffset;
 926         if (framesToEnd <= 0) return true;
 927
 928         SNDFILE* sf = sf_open(mFilename, SFM_READ, &fileinfo);
 929         if (!sf) {
 930                 char str[512];
 931                 sprintf(str, "File '%s' could not be opened: %s\n", mFilename, sf_strerror(NULL));
 932                 SendFailureWithBufnum(&mReplyAddress, "/b_readChannel", str, mBufIndex); //SendFailure(&mReplyAddress, "/b_read", str);
 933                 scprintf(str);
 934                 return false;
 935         }
 936
 937         if (mNumChannels > 0) {
 938                 // verify channel indexes
 939                 if (!( CheckChannels(fileinfo.channels)) ) { // nescivi:  && CheckChannels(buf->channels) (should not check here for buf->channels)
 940             const char* str = "Channel index out of range.\n";
 941                         SendFailureWithBufnum(&mReplyAddress, "/b_readChannel", str, mBufIndex); //SendFailure(&mReplyAddress, "/b_allocRead", str);
 942                         scprintf(str);
 943                         sf_close(sf);
 944                         return false;
 945                 }
 946 // nescivi: this also seems out of place: we want to read from a file with more channels than are in the buffer
 947 //      } else if (fileinfo.channels != buf->channels) {
 948 //              char str[256];
 949 //              sf_close(sf);
 950 //              sprintf(str, "Channel mismatch. File '%s' has %d channels. Buffer has %d channels.\n",
 951 //                              mFilename, fileinfo.channels, buf->channels);
 952 //              SendFailure(&mReplyAddress, "/b_read", str);
 953 //              scprintf(str);
 954 //              return false;
 955         }
 956
 957         if (mFileOffset < 0) mFileOffset = 0;
 958         else if (mFileOffset > fileinfo.frames) mFileOffset = fileinfo.frames;
 959         if (mNumFrames < 0 || mNumFrames + mFileOffset > fileinfo.frames) mNumFrames = fileinfo.frames - mFileOffset;
 960         if (mNumFrames > framesToEnd) mNumFrames = framesToEnd;
 961
 962         sf_seek(sf, mFileOffset, SEEK_SET);
 963         if (mNumFrames > 0) {
 964                 if (mNumChannels == 0) {
 965                         // read all channels
 966                         sf_readf_float(sf, buf->data + (mBufOffset * buf->channels), mNumFrames);
 967                 } else {
 968                         // alloc temp buffer
 969                         float* data = (float*)malloc(mNumFrames*fileinfo.channels*sizeof(float));
 970                         if (data == 0) goto leave;
 971                         // read some channels
 972                         sf_seek(sf, mFileOffset, SEEK_SET);
 973                         sf_readf_float(sf, data, mNumFrames);
 974                         CopyChannels(buf->data + (mBufOffset * mNumChannels), data, fileinfo.channels, mNumFrames);
 975                         // free temp buffer
 976                         free(data);
 977                 }
 978         }
 979
 980 leave:
 981         if(buf->sndfile)
 982                 sf_close(buf->sndfile);
 983
 984         if (mLeaveFileOpen) {
 985                 buf->sndfile = sf;
 986         } else {
 987                 sf_close(sf);
 988                 buf->sndfile = 0;
 989         }
 990
 991         mSampleRate = (double)fileinfo.samplerate;
 992
 993         return true;
 994 #endif
 995 }
 996
 997 bool BufReadChannelCmd::Stage3()
 998 {
 999         SndBuf* buf = World_GetBuf(mWorld, mBufIndex);
1000         buf->samplerate = mSampleRate;
1001         if (mLeaveFileOpen) buf->mask = buf->mask1 = -1;
1002
1003         mWorld->mSndBufUpdates[mBufIndex].writes ++ ;
1004         SEND_COMPLETION_MSG;
1005         return true;
1006 }
1007
1008 void BufReadChannelCmd::Stage4()
1009 {
1010         SendDoneWithIntValue("/b_readChannel", mBufIndex);
1011 }
1012
1013 ///////////////////////////////////////////////////////////////////////////
1014
1015 BufWriteCmd::BufWriteCmd(World *inWorld, ReplyAddress *inReplyAddress)
1016         : SC_SequencedCommand(inWorld, inReplyAddress), mFilename(0)
1017 {
1018 }
1019
1020 #ifdef NO_LIBSNDFILE
1021 struct SF_INFO {};
1022 #endif
1023
1024 int BufWriteCmd::Init(char *inData, int inSize)
1025 {
1026 #ifdef NO_LIBSNDFILE
1027         SendFailure(&mReplyAddress, "/b_write", "scsynth compiled without libsndfile\n");
1028         scprintf("scsynth compiled without libsndfile\n");
1029         return false;
1030 #else
1031         sc_msg_iter msg(inSize, inData);
1032         mBufIndex = msg.geti();
1033
1034         const char *filename = msg.gets();
1035         if (!filename) return kSCErr_WrongArgType;
1036
1037         if(mWorld->mRestrictedPath){
1038                 mFilename = allocAndRestrictPath(mWorld, filename, mWorld->mRestrictedPath);
1039         }else{
1040                 mFilename = (char*)World_Alloc(mWorld, strlen(filename)+1);
1041                 strcpy(mFilename, filename);
1042         }
1043
1044         const char *headerFormatString = msg.gets("aiff");
1045         const char *sampleFormatString = msg.gets("int16");
1046
1047         mNumFrames = msg.geti(-1);
1048         mBufOffset = msg.geti();
1049         mLeaveFileOpen = msg.geti();
1050
1051         GET_COMPLETION_MSG(msg);
1052
1053         memset(&mFileInfo, 0, sizeof(mFileInfo));
1054         return sndfileFormatInfoFromStrings(&mFileInfo, headerFormatString, sampleFormatString);
1055 #endif
1056 }
1057
1058 BufWriteCmd::~BufWriteCmd()
1059 {
1060         World_Free(mWorld, mFilename);
1061 }
1062
1063 void BufWriteCmd::CallDestructor()
1064 {
1065         this->~BufWriteCmd();
1066 }
1067
1068 bool BufWriteCmd::Stage2()
1069 {
1070 #ifdef NO_LIBSNDFILE
1071         return false;
1072 #else
1073         SndBuf *buf = World_GetNRTBuf(mWorld, mBufIndex);
1074         int framesToEnd = buf->frames - mBufOffset;
1075         if (framesToEnd < 0) framesToEnd = 0;
1076         mFileInfo.samplerate = (int)buf->samplerate;
1077         mFileInfo.channels = buf->channels;
1078
1079         SNDFILE* sf = sf_open(mFilename, SFM_WRITE, &mFileInfo);
1080         if (!sf) {
1081                 char str[512];
1082                 sprintf(str, "File '%s' could not be opened: %s\n", mFilename, sf_strerror(NULL));
1083                 SendFailureWithBufnum(&mReplyAddress, "/b_write", str, mBufIndex); //SendFailure(&mReplyAddress, "/b_write", str);
1084                 scprintf(str);
1085                 return false;
1086         }
1087
1088         if (mNumFrames < 0 || mNumFrames > buf->frames) mNumFrames = buf->frames;
1089
1090         if (mNumFrames > framesToEnd) mNumFrames = framesToEnd;
1091
1092         if (mNumFrames > 0) {
1093                 sf_writef_float(sf, buf->data + (mBufOffset * buf->channels), mNumFrames);
1094         }
1095
1096         if(buf->sndfile)
1097                 sf_close(buf->sndfile);
1098
1099         if (mLeaveFileOpen) {
1100                 buf->sndfile = sf;
1101         } else {
1102                 sf_close(sf);
1103                 buf->sndfile = 0;
1104         }
1105
1106         return true;
1107 #endif
1108 }
1109
1110 bool BufWriteCmd::Stage3()
1111 {
1112         SEND_COMPLETION_MSG;
1113         return true;
1114 }
1115
1116 void BufWriteCmd::Stage4()
1117 {
1118         SendDoneWithIntValue("/b_write", mBufIndex);
1119 }
1120
1121 ///////////////////////////////////////////////////////////////////////////
1122
1123 BufCloseCmd::BufCloseCmd(World *inWorld, ReplyAddress *inReplyAddress)
1124         : SC_SequencedCommand(inWorld, inReplyAddress)
1125 {
1126 }
1127
1128 int BufCloseCmd::Init(char *inData, int inSize)
1129 {
1130         sc_msg_iter msg(inSize, inData);
1131         mBufIndex = msg.geti();
1132
1133         GET_COMPLETION_MSG(msg);
1134
1135         return kSCErr_None;
1136 }
1137
1138 void BufCloseCmd::CallDestructor()
1139 {
1140         this->~BufCloseCmd();
1141 }
1142
1143 bool BufCloseCmd::Stage2()
1144 {
1145 #ifdef NO_LIBSNDFILE
1146         SendFailure(&mReplyAddress, "/b_close", "scsynth compiled without libsndfile\n");
1147         scprintf("scsynth compiled without libsndfile\n");
1148         return false;
1149 #else
1150         SndBuf *buf = World_GetNRTBuf(mWorld, mBufIndex);
1151         if (buf->sndfile) {
1152                 sf_close(buf->sndfile);
1153                 buf->sndfile = 0;
1154         }
1155         return true;
1156 #endif
1157 }
1158
1159 bool BufCloseCmd::Stage3()
1160 {
1161         SEND_COMPLETION_MSG;
1162         return true;
1163 }
1164
1165 void BufCloseCmd::Stage4()
1166 {
1167         SendDoneWithIntValue("/b_close", mBufIndex);
1168 }
1169
1170 ///////////////////////////////////////////////////////////////////////////
1171
1172 AudioQuitCmd::AudioQuitCmd(World *inWorld, ReplyAddress *inReplyAddress)
1173         : SC_SequencedCommand(inWorld, inReplyAddress)
1174 {
1175 }
1176
1177 void AudioQuitCmd::CallDestructor()
1178 {
1179         this->~AudioQuitCmd();
1180 }
1181
1182 bool AudioQuitCmd::Stage2()
1183 {
1184         mWorld->hw->mTerminating = true;
1185         return true;
1186 }
1187
1188 bool AudioQuitCmd::Stage3()
1189 {
1190 #if SC_AUDIO_API == SC_AUDIO_API_AUDIOUNITS
1191         SendFailure(&mReplyAddress, "/quit", "not allowed in AU host\n");
1192         scprintf("/quit : quit not allowed in AU host\n");
1193         return false;
1194 #else
1195         if (mWorld->hw->mShmem)
1196                 mWorld->hw->mShmem->disconnect();
1197         return true;
1198 #endif
1199 }
1200
1201 void AudioQuitCmd::Stage4()
1202 {
1203         SendDone("/quit");
1204         mWorld->hw->mQuitProgram->Release();
1205 }
1206
1207 ///////////////////////////////////////////////////////////////////////////
1208
1209 AudioStatusCmd::AudioStatusCmd(World *inWorld, ReplyAddress *inReplyAddress)
1210         : SC_SequencedCommand(inWorld, inReplyAddress)
1211 {
1212 }
1213
1214 void AudioStatusCmd::CallDestructor()
1215 {
1216         this->~AudioStatusCmd();
1217 }
1218
1219 bool AudioStatusCmd::Stage2()
1220 {
1221         // we stop replying to status requests after receiving /quit
1222         if (mWorld->hw->mTerminating == true)
1223                 return false;
1224
1225         small_scpacket packet;
1226         packet.adds("/status.reply");
1227         packet.maketags(10);
1228         packet.addtag(',');
1229         packet.addtag('i');
1230         packet.addtag('i');
1231         packet.addtag('i');
1232         packet.addtag('i');
1233         packet.addtag('i');
1234         packet.addtag('f');
1235         packet.addtag('f');
1236         packet.addtag('d');
1237         packet.addtag('d');
1238
1239         packet.addi(1); // audio is always active now.
1240         packet.addi(mWorld->mNumUnits);
1241         packet.addi(mWorld->mNumGraphs);
1242         packet.addi(mWorld->mNumGroups);
1243         packet.addi(mWorld->hw->mGraphDefLib->NumItems());
1244
1245         SC_AudioDriver *driver = mWorld->hw->mAudioDriver;
1246         packet.addf(driver->GetAvgCPU());
1247         packet.addf(driver->GetPeakCPU());
1248         packet.addd(driver->GetSampleRate());
1249         packet.addd(driver->GetActualSampleRate());
1250
1251         SendReply(&mReplyAddress, packet.data(), packet.size());
1252
1253         return false;
1254 }
1255
1256 ///////////////////////////////////////////////////////////////////////////
1257
1258 NotifyCmd::NotifyCmd(World *inWorld, ReplyAddress *inReplyAddress)
1259         : SC_SequencedCommand(inWorld, inReplyAddress)
1260 {
1261 }
1262
1263 int NotifyCmd::Init(char *inData, int inSize)
1264 {
1265         sc_msg_iter msg(inSize, inData);
1266         mOnOff = msg.geti();
1267
1268         return kSCErr_None;
1269 }
1270
1271 void NotifyCmd::CallDestructor()
1272 {
1273         this->~NotifyCmd();
1274 }
1275
1276 bool NotifyCmd::Stage2()
1277 {
1278         HiddenWorld *hw = mWorld->hw;
1279
1280         if (mOnOff) {
1281                 for (uint32 i=0; i<hw->mNumUsers; ++i) {
1282                         if (mReplyAddress == hw->mUsers[i]) {
1283                                 // already in table - don't fail though..
1284                                 SendFailure(&mReplyAddress, "/notify", "notify: already registered\n");
1285                                 scprintf("/notify : already registered\n");
1286                                 return false;
1287                         }
1288                 }
1289
1290                 // add reply address to user table
1291                 if (hw->mNumUsers >= hw->mMaxUsers) {
1292                         SendFailure(&mReplyAddress, "/notify", "too many users\n");
1293                         scprintf("too many users\n");
1294                         return false;
1295                 }
1296
1297                 hw->mUsers[hw->mNumUsers++] = mReplyAddress;
1298
1299                 SendDone("/notify");
1300         } else {
1301                 for (uint32 i=0; i<hw->mNumUsers; ++i) {
1302                         if (mReplyAddress == hw->mUsers[i]) {
1303                                 // remove from list
1304                                 hw->mUsers[i] = hw->mUsers[--hw->mNumUsers];
1305                                 SendDone("/notify");
1306                                 return false;
1307                         }
1308                 }
1309
1310                 SendFailure(&mReplyAddress, "/notify", "not registered\n");
1311                 scprintf("not registered\n");
1312         }
1313         return false;
1314 }
1315
1316 ///////////////////////////////////////////////////////////////////////////
1317
1318 SendFailureCmd::SendFailureCmd(World *inWorld, ReplyAddress *inReplyAddress)
1319         : SC_SequencedCommand(inWorld, inReplyAddress), mCmdName(0), mErrString(0)
1320 {
1321 }
1322
1323 SendFailureCmd::~SendFailureCmd()
1324 {
1325         World_Free(mWorld, mCmdName);
1326         World_Free(mWorld, mErrString);
1327 }
1328
1329
1330 void SendFailureCmd::InitSendFailureCmd(const char *inCmdName, const char* inErrString)
1331 {
1332         mCmdName = (char*)World_Alloc(mWorld, strlen(inCmdName)+1);
1333         strcpy(mCmdName, inCmdName);
1334
1335         mErrString = (char*)World_Alloc(mWorld, strlen(inErrString)+1);
1336         strcpy(mErrString, inErrString);
1337 }
1338
1339 void SendFailureCmd::CallDestructor()
1340 {
1341         this->~SendFailureCmd();
1342 }
1343
1344 bool SendFailureCmd::Stage2()
1345 {
1346         SendFailure(&mReplyAddress, mCmdName, mErrString);
1347         return false;
1348 }
1349
1350 ///////////////////////////////////////////////////////////////////////////
1351
1352 RecvSynthDefCmd::RecvSynthDefCmd(World *inWorld, ReplyAddress *inReplyAddress)
1353         : SC_SequencedCommand(inWorld, inReplyAddress), mBuffer(0)
1354 {
1355 }
1356
1357 int RecvSynthDefCmd::Init(char *inData, int inSize)
1358 {
1359         sc_msg_iter msg(inSize, inData);
1360
1361         int size = msg.getbsize();
1362         if (!size) throw kSCErr_WrongArgType;
1363
1364         mBuffer = (char*)World_Alloc(mWorld, size);
1365         msg.getb(mBuffer, size);
1366
1367         GET_COMPLETION_MSG(msg);
1368
1369         mDefs = 0;
1370         return kSCErr_None;
1371 }
1372
1373 RecvSynthDefCmd::~RecvSynthDefCmd()
1374 {
1375         World_Free(mWorld, mBuffer);
1376 }
1377
1378 void RecvSynthDefCmd::CallDestructor()
1379 {
1380         this->~RecvSynthDefCmd();
1381 }
1382
1383 bool RecvSynthDefCmd::Stage2()
1384 {
1385         mDefs = GraphDef_Recv(mWorld, mBuffer, mDefs);
1386
1387         return true;
1388 }
1389
1390 bool RecvSynthDefCmd::Stage3()
1391 {
1392         GraphDef_Define(mWorld, mDefs);
1393         SEND_COMPLETION_MSG;
1394         return true;
1395 }
1396
1397 void RecvSynthDefCmd::Stage4()
1398 {
1399         SendDone("/d_recv");
1400 }
1401
1402 ///////////////////////////////////////////////////////////////////////////
1403
1404 LoadSynthDefCmd::LoadSynthDefCmd(World *inWorld, ReplyAddress *inReplyAddress)
1405         : SC_SequencedCommand(inWorld, inReplyAddress), mFilename(0)
1406 {
1407 }
1408
1409 int LoadSynthDefCmd::Init(char *inData, int inSize)
1410 {
1411         sc_msg_iter msg(inSize, inData);
1412
1413         const char *filename = msg.gets();
1414         if (!filename) return kSCErr_WrongArgType;
1415
1416         if(mWorld->mRestrictedPath){
1417                 mFilename = allocAndRestrictPath(mWorld, filename, mWorld->mRestrictedPath);
1418         }else{
1419                 mFilename = (char*)World_Alloc(mWorld, strlen(filename)+1);
1420                 strcpy(mFilename, filename);
1421         }
1422
1423         GET_COMPLETION_MSG(msg);
1424
1425         mDefs = 0;
1426         return kSCErr_None;
1427 }
1428
1429 LoadSynthDefCmd::~LoadSynthDefCmd()
1430 {
1431         World_Free(mWorld, mFilename);
1432 }
1433
1434 void LoadSynthDefCmd::CallDestructor()
1435 {
1436         this->~LoadSynthDefCmd();
1437 }
1438
1439 bool LoadSynthDefCmd::Stage2()
1440 {
1441         char* fname = mFilename;
1442         mDefs = GraphDef_LoadGlob(mWorld, fname, mDefs);
1443         return true;
1444 }
1445
1446 bool LoadSynthDefCmd::Stage3()
1447 {
1448         GraphDef_Define(mWorld, mDefs);
1449         SEND_COMPLETION_MSG;
1450         return true;
1451 }
1452
1453 void LoadSynthDefCmd::Stage4()
1454 {
1455         SendDone("/d_load");
1456 }
1457
1458 ///////////////////////////////////////////////////////////////////////////
1459
1460 LoadSynthDefDirCmd::LoadSynthDefDirCmd(World *inWorld, ReplyAddress *inReplyAddress)
1461         : SC_SequencedCommand(inWorld, inReplyAddress), mFilename(0)
1462 {
1463 }
1464
1465 int LoadSynthDefDirCmd::Init(char *inData, int inSize)
1466 {
1467         sc_msg_iter msg(inSize, inData);
1468
1469         const char *filename = msg.gets();
1470         if (!filename) return kSCErr_WrongArgType;
1471
1472         if(mWorld->mRestrictedPath){
1473                 mFilename = allocAndRestrictPath(mWorld, filename, mWorld->mRestrictedPath);
1474         }else{
1475                 mFilename = (char*)World_Alloc(mWorld, strlen(filename)+1);
1476                 strcpy(mFilename, filename);
1477         }
1478
1479         GET_COMPLETION_MSG(msg);
1480
1481         mDefs = 0;
1482         return kSCErr_None;
1483 }
1484
1485 LoadSynthDefDirCmd::~LoadSynthDefDirCmd()
1486 {
1487         World_Free(mWorld, mFilename);
1488 }
1489
1490 void LoadSynthDefDirCmd::CallDestructor()
1491 {
1492         this->~LoadSynthDefDirCmd();
1493 }
1494
1495 bool LoadSynthDefDirCmd::Stage2()
1496 {
1497         mDefs = GraphDef_LoadDir(mWorld, mFilename, mDefs);
1498
1499         return true;
1500 }
1501
1502 bool LoadSynthDefDirCmd::Stage3()
1503 {
1504         GraphDef_Define(mWorld, mDefs);
1505         SEND_COMPLETION_MSG;
1506         return true;
1507 }
1508
1509 void LoadSynthDefDirCmd::Stage4()
1510 {
1511         SendDone("/d_loadDir");
1512 }
1513
1514 ///////////////////////////////////////////////////////////////////////////
1515
1516 SendReplyCmd::SendReplyCmd(World *inWorld, ReplyAddress *inReplyAddress)
1517         : SC_SequencedCommand(inWorld, inReplyAddress)
1518 {
1519 }
1520
1521 int SendReplyCmd::Init(char *inData, int inSize)
1522 {
1523         mMsgSize = inSize;
1524         mMsgData = (char*)World_Alloc(mWorld, mMsgSize);
1525         memcpy(mMsgData, inData, inSize);
1526         return kSCErr_None;
1527 }
1528
1529 void SendReplyCmd::CallDestructor()
1530 {
1531         this->~SendReplyCmd();
1532 }
1533
1534 bool SendReplyCmd::Stage2()
1535 {
1536         SendReply(&mReplyAddress, mMsgData, mMsgSize);
1537         return false;
1538 }
1539
1540 ///////////////////////////////////////////////////////////////////////////
1541
1542 int PerformAsynchronousCommand(
1543                         World *inWorld,
1544                         void* replyAddr,
1545                         const char* cmdName,
1546                         void *cmdData,
1547                         AsyncStageFn stage2, // stage2 is non real time
1548                         AsyncStageFn stage3, // stage3 is real time - completion msg performed if stage3 returns true
1549                         AsyncStageFn stage4, // stage4 is non real time - sends done if stage4 returns true
1550                         AsyncFreeFn cleanup,
1551                         int completionMsgSize,
1552                         void* completionMsgData
1553 )
1554 {
1555         void* space = World_Alloc(inWorld, sizeof(AsyncPlugInCmd));
1556         AsyncPlugInCmd *cmd = new (space) AsyncPlugInCmd(inWorld, (ReplyAddress*)replyAddr,
1557                                                                 cmdName, cmdData, stage2, stage3, stage4, cleanup,
1558                                                                 completionMsgSize, completionMsgData);
1559         if (!cmd) return kSCErr_Failed;
1560         if (inWorld->mRealTime) cmd->CallNextStage();
1561         else cmd->CallEveryStage();
1562         return kSCErr_None;
1563 }
1564
1565 ///////////////////////////////////////////////////////////////////////////
1566
1567 AsyncPlugInCmd::AsyncPlugInCmd(World *inWorld, ReplyAddress *inReplyAddress,
1568                         const char* cmdName,
1569                         void *cmdData,
1570                         AsyncStageFn stage2, // stage2 is non real time
1571                         AsyncStageFn stage3, // stage3 is real time - completion msg performed if stage3 returns true
1572                         AsyncStageFn stage4, // stage4 is non real time - sends done if stage4 returns true
1573                         AsyncFreeFn cleanup, // cleanup is called in real time
1574                         int completionMsgSize,
1575                         void* completionMsgData)
1576         : SC_SequencedCommand(inWorld, inReplyAddress),
1577         mCmdName(cmdName), mCmdData(cmdData),
1578         mStage2(stage2), mStage3(stage3), mStage4(stage4),
1579         mCleanup(cleanup)
1580 {
1581         if (completionMsgSize && completionMsgData) {
1582                 mMsgSize = completionMsgSize;
1583                 mMsgData = (char*)World_Alloc(mWorld, mMsgSize);
1584                 memcpy(mMsgData, completionMsgData, mMsgSize);
1585         }
1586 }
1587
1588 AsyncPlugInCmd::~AsyncPlugInCmd()
1589 {
1590         (mCleanup)(mWorld, mCmdData);
1591         if (mMsgData) World_Free(mWorld, mMsgData);
1592 }
1593
1594 void AsyncPlugInCmd::CallDestructor()
1595 {
1596         this->~AsyncPlugInCmd();
1597 }
1598
1599 bool AsyncPlugInCmd::Stage2()
1600 {
1601         bool result = !mStage2 || (mStage2)(mWorld, mCmdData);
1602         return result;
1603 }
1604
1605 bool AsyncPlugInCmd::Stage3()
1606 {
1607         bool result = !mStage3 || (mStage3)(mWorld, mCmdData);
1608         if (result) SEND_COMPLETION_MSG;
1609         return result;
1610 }
1611
1612 void AsyncPlugInCmd::Stage4()
1613 {
1614         bool result = !mStage4 || (mStage4)(mWorld, mCmdData);
1615         if (result && mCmdName && mReplyAddress.mReplyFunc != null_reply_func) SendDone((char*)mCmdName);
1616 }
1617
1618