1

2

3

4

5

6

7

8

9

10

11#pragma once

12

20#include <algorithm>

21#include "wdlstring.h"

22#include "ptrlist.h"

23

26#include "IPlugMidi.h"

28

29BEGIN_IPLUG_NAMESPACE

30

33{

34 int idx;

35 double value;

36

37 ParamTuple(int idx = kNoParameter, double value = 0.)

38 : idx(idx)

39 , value(value)

40 {}

41};

42

45{

46 SysExData(int offset = 0, int size = 0, const void* pData = 0)

47 : mOffset(offset)

48 , mSize(size)

49 {

50 assert(size < MAX_SYSEX_SIZE);

51

52 if (pData)

53 memcpy(mData, pData, size);

54 else

55 memset(mData, 0, MAX_SYSEX_SIZE);

56 }

57

58 int mOffset;

59 int mSize;

60 uint8_t mData[MAX_SYSEX_SIZE];

61};

62

65{

73 static inline int GetBytes(const uint8_t* pSrc, int srcSize, void* pDst, int nBytesToCopy, int startPos)

74 {

75 int endPos = startPos + nBytesToCopy;

76 if (startPos >= 0 && endPos <= srcSize)

77 {

78 memcpy(pDst, pSrc + startPos, nBytesToCopy);

79 return endPos;

80 }

81 return -1;

82 }

83

90 static inline int GetStr(const uint8_t* pSrc, int srcSize, WDL_String& str, int startPos)

91 {

92 int len;

93 int strStartPos = GetBytes(pSrc, srcSize, &len, sizeof(len), startPos);

94 if (strStartPos >= 0)

95 {

96 int strEndPos = strStartPos + len;

97 if (strEndPos <= srcSize)

98 {

99 if (len > 0)

100 str.Set((char*) (pSrc + strStartPos), len);

101 else

102 str.Set("");

103 }

104 return strEndPos;

105 }

106 return -1;

107 }

108};

109

112{

113public:

116

120 {

122 int magic = IPLUG_VERSION_MAGIC;

123 chunk.Put(&magic);

124 int ver = IPLUG_VERSION;

125 chunk.Put(&ver);

126 }

127

133 {

134 int magic = 0, ver = 0;

135 int magicpos = chunk.Get(&magic, position);

136

137 if (magicpos > position && magic == IPLUG_VERSION_MAGIC)

138 position = chunk.Get(&ver, magicpos);

139

140 return ver;

141 }

142

147 inline int PutBytes(const void* pSrc, int nBytesToCopy)

148 {

149 int n = mBytes.GetSize();

150 mBytes.Resize(n + nBytesToCopy);

151 memcpy(mBytes.Get() + n, pSrc, nBytesToCopy);

152 return mBytes.GetSize();

153 }

154

160 inline int GetBytes(void* pDst, int nBytesToCopy, int startPos) const

161 {

163 }

164

169 template <class T>

170 inline int Put(const T* pVal)

171 {

172 return PutBytes(pVal, sizeof(T));

173 }

174

180 template <class T>

181 inline int Get(T* pDst, int startPos) const

182 {

183 return GetBytes(pDst, sizeof(T), startPos);

184 }

185

189 inline int PutStr(const char* str)

190 {

191 int slen = (int) strlen(str);

192 Put(&slen);

194 }

195

200 inline int GetStr(WDL_String& str, int startPos) const

201 {

203 }

204

209 {

211 }

212

215 {

216 mBytes.Resize(0);

217 }

218

222 {

223 return mBytes.GetSize();

224 }

225

230 {

231 int n = mBytes.GetSize();

232 mBytes.Resize(newSize);

233 if (newSize > n)

234 {

235 memset(mBytes.Get() + n, 0, (newSize - n));

236 }

237 return n;

238 }

239

243 {

244 return mBytes.Get();

245 }

246

249 inline const uint8_t* GetData() const

250 {

251 return mBytes.Get();

252 }

253

258 {

259 return (otherChunk.Size() == Size() && !memcmp(otherChunk.mBytes.Get(), mBytes.Get(), Size()));

260 }

261

262private:

263 WDL_TypedBuf<uint8_t> mBytes;

264};

265

268{

269public:

270 IByteStream(const void *pData, int dataSize) : mBytes(reinterpret_cast<const uint8_t *>(pData)), mSize(dataSize) {}

272

278 inline int GetBytes(void* pDst, int nBytesToCopy, int startPos) const

279 {

281 }

282

288 template <class T>

289 inline int Get(T* pDst, int startPos) const

290 {

291 return GetBytes(pDst, sizeof(T), startPos);

292 }

293

298 inline int GetStr(WDL_String& str, int startPos) const

299 {

301 }

302

306 {

307 return mSize;

308 }

309

314 {

315 return (otherStream.Size() == Size() && !memcmp(otherStream.mBytes, mBytes, Size()));

316 }

317

321 {

322 return mBytes;

323 }

324

325private:

326 const uint8_t* mBytes;

327 int mSize;

328};

329

332{

333public:

335 : mChunk(chunk)

336 , mPos(startPos)

337 {

338 }

339

344 inline int GetBytes(void* pBuf, int nBytesToCopy)

345 {

346 mPos = mChunk.GetBytes(pBuf, nBytesToCopy, mPos);

347 return mPos;

348 }

349

354 template <class T>

355 inline int Get(T* pDst)

356 {

357 mPos = mChunk.Get(pDst, mPos);

358 return mPos;

359 }

360

364 inline int GetStr(WDL_String& str)

365 {

366 mPos = mChunk.GetStr(str, mPos);

367 return mPos;

368 }

369

373 {

374 return mPos;

375 }

376

379 inline void Seek(int pos)

380 {

381 mPos = pos;

382 }

383

384private:

386 int mPos;

387};

388

390struct Config

391{

392 int nParams;

393 int nPresets;

394 const char* channelIOStr;

395 const char* pluginName;

396 const char* productName;

397 const char* mfrName;

398 int vendorVersion;

399 int uniqueID;

400 int mfrID;

401 int latency;

402 bool plugDoesMidiIn;

403 bool plugDoesMidiOut;

404 bool plugDoesMPE;

405 bool plugDoesChunks;

406 int plugType;

407 bool plugHasUI;

408 int plugWidth;

409 int plugHeight;

410 int plugMinWidth;

411 int plugMaxWidth;

412 int plugMinHeight;

413 int plugMaxHeight;

414 bool plugHostResize;

415 const char* bundleID;

416 const char* appGroupID;

417

418 Config(int nParams,

419 int nPresets,

420 const char* channelIOStr,

421 const char* pluginName,

422 const char* productName,

423 const char* mfrName,

424 int vendorVersion,

425 int uniqueID,

426 int mfrID,

427 int latency,

428 bool plugDoesMidiIn,

429 bool plugDoesMidiOut,

430 bool plugDoesMPE,

431 bool plugDoesChunks,

432 int plugType,

433 bool plugHasUI,

434 int plugWidth,

435 int plugHeight,

436 bool plugHostResize,

437 int plugMinWidth,

438 int plugMaxWidth,

439 int plugMinHeight,

440 int plugMaxHeight,

441 const char* bundleID,

442 const char* appGroupID)

443

444 : nParams(nParams)

445 , nPresets(nPresets)

446 , channelIOStr(channelIOStr)

447 , pluginName(pluginName)

448 , productName(productName)

449 , mfrName(mfrName)

450 , vendorVersion(vendorVersion)

451 , uniqueID(uniqueID)

452 , mfrID(mfrID)

453 , latency(latency)

454 , plugDoesMidiIn(plugDoesMidiIn)

455 , plugDoesMidiOut(plugDoesMidiOut)

456 , plugDoesMPE(plugDoesMPE)

457 , plugDoesChunks(plugDoesChunks)

458 , plugType(plugType)

459 , plugHasUI(plugHasUI)

460 , plugWidth(plugWidth)

461 , plugHeight(plugHeight)

462 , plugMinWidth(plugMinWidth)

463 , plugMaxWidth(plugMaxWidth)

464 , plugMinHeight(plugMinHeight)

465 , plugMaxHeight(plugMaxHeight)

466 , plugHostResize(plugHostResize)

467 , bundleID(bundleID)

468 , appGroupID(appGroupID)

469 {};

470};

471

473template<class TIN = PLUG_SAMPLE_SRC, class TOUT = PLUG_SAMPLE_DST>

475{

476 bool mConnected = false;

477 TOUT** mData = nullptr;

478 TIN* mIncomingData = nullptr;

479 WDL_TypedBuf<TOUT> mScratchBuf;

480 WDL_String mLabel;

481};

482

485{

486public:

488 : mDirection(direction)

489 , mNChans(nchans)

490 {

491 }

492

493 int NChans() const { return mNChans; }

494

495 ERoute GetDirection() const { return mDirection; }

496

497private:

499 int mNChans;

500};

501

504{

505 WDL_PtrList<IBusInfo> mBusInfo[2];

506

508 {

509 mBusInfo[0].Empty(true);

510 mBusInfo[1].Empty(true);

511 }

512

517 {

518 mBusInfo[direction].Add(new IBusInfo(direction, NChans));

519 }

520

526 {

527 assert(index >= 0 && index < mBusInfo[direction].GetSize());

528 return mBusInfo[direction].Get(index);

529 }

530

536 {

537 int NChans = 0;

538

539 if(index >= 0 && index < mBusInfo[direction].GetSize())

540 NChans = mBusInfo[direction].Get(index)->NChans();

541

542 return NChans;

543 }

544

549 {

550 return mBusInfo[direction].GetSize();

551 }

552

557 {

558 int total = 0;

559

560 for(int i = 0; i < mBusInfo[direction].GetSize(); i++)

561 total += mBusInfo[direction].Get(i)->NChans();

562

563 return total;

564 }

565

571 {

572 for(auto i = 0; i < mBusInfo[direction].GetSize(); i++)

573 {

574 if(mBusInfo[direction].Get(i)->NChans() < 0)

575 return true;

576 }

577

578 return false;

579 }

580};

581

584{

585 double mTempo = DEFAULT_TEMPO;

586 double mSamplePos = -1.0;

587 double mPPQPos = -1.0;

588 double mLastBar = -1.0;

589 double mCycleStart = -1.0;

590 double mCycleEnd = -1.0;

591

592 int mNumerator = 4;

593 int mDenominator = 4;

594

595 bool mTransportIsRunning = false;

596 bool mTransportLoopEnabled = false;

597};

598

601{

602 bool mInitialized = false;

603 char mName[MAX_PRESET_NAME_LEN];

604

606

608 {

609 snprintf(mName, MAX_PRESET_NAME_LEN, "%s", UNUSED_PRESET_NAME);

610 }

611};

612

615{

616 int VK;

617 char utf8[5] = { 0 };

618 bool S, C, A;

619

626 IKeyPress(const char* _utf8, int vk, bool s = false, bool c = false, bool a = false)

627 : VK(vk)

628 , S(s), C(c), A(a)

629 {

630 strcpy(utf8, _utf8);

631 }

632

633 void DBGPrint() const { DBGMSG("VK: %i\n", VK); }

634};

635

636END_IPLUG_NAMESPACE

637