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